This program has been developed in several NMR groups in France, first in I.C.S.N. in Gif/Yvette, then in Ecole Polytechnique in Palaiseau and now in Montpellier under the coordination of Marc-André Delsuc. Please contact :

M.A.Delsuc

Centre de Biochimie Structurale

Faculté de Pharmacie,

15 avenue Charles Flahault

34060 Montpellier Cedex FRANCE.

E-Mail : mad@cbs.univ-montp1.fr (Internet)

Tel : (33) 67 04 34 36 (In case of emergency)

The program includes all the classical processing, displaying and plotting capabilities of an NMR program, as well as more advanced processing techniques such as Maximum Entropy processing or Linear prediction. There is no actual limit to the size of the data-set which can be processed. A complete macro language permits to builds sophisticated processing. The Graphic User Interface is fully designable and programmable by the user.

The program currently runs on several UNIX platforms. The graphics can be displayed on X-Windows terminals. Plots are generated on postscript or HP-GL devices.

This version V4.0 is now in final version, however it is evoluating all the time, check your ftp server ! This version is distributed under a licence. There is no fees for academic laboratories, however the licence requires that you refer to Gifa in any published work which depend in some manner on the Gifa program.

This program can be downloaded by anonymous FTP on Internet, the home site is the following address : ftp://tome.cbs.univ-montp1.fr/pub/gifa_v4 .

Previous released versions have been : 1.0 (Initial VMS Version), 1.1 (revised version), 2.0 (first port to UNIX), 2.1 (first stabilised version), 2.5 (introduction of linear prediction, polynomial baseline correction), 3.0 (introduction of macro-language, on-file processing, etc...), 3.1 (new peak-picker and line-fitter), 4.0 (Motif version, new user interface, new language capabilities, new cache, extended line fitter). Several versions have been used internally in our lab, and may have been released by mistake.

*Full array of apodisation functions (shifted sine-bells and squared sine-bells; exponential; Gaussian; trapezoid, and combinations).

*Fast Fourier transform (direct and inverse; real, complex, and hypercomplex). Hilbert transforms.

*Zero-filling and truncation.

*Phasing of 1D, 2D and 3D spectra.

*Processing in memory (for regular data size) or on disk (for very large data-set) with similar syntaxes

*Non-limited size data-set with optimised file access protocol.

*Very fast processing :

* 2'30" on Macintosh Centris 650 - running MachTen

* 37" on SUN SparcStation 2

* 31" on IBM Risc 6000-320

* 17" on HP 725/50

* 15.5" on SGI-INDY PC

* 12.6" on IBM Risc 6000-560

* 12.3" on SUN Sparc 20

* 10.4" on SGI-INDY R4400

* 7.5" on HP 735/99

for the complete processing of a 512x2048 data points data-set, including :

-exponential windowing in F2, shifted sine bell in F1.

-hypercomplex FT with zero-filling in F1 and phasing in both axes.

-cubic spline baseline correction through 5 points in F2.

*Post-processing filters; modulus, real part extraction, absolute value, smoothing, etc...

*Complete baseline correction module (linear, cubic spline correction, and a comprehensive polynomial module with automatic peak detection).

*Extraction of sub-spectra for local processing.

*Simulation of pseudo data-sets. Simulation of 2D NOESY from intensity files (CORMA type)

*3D Display in 3D perspective

*Random access to rows, columns, diagonals or projections in 2D mode.

*Random access to planes and rows in any direction or diagonals in 3D mode.

*Multi-windowing facilities : up to 4 active windows in the same time, many passive windows.

*Fast zoom mode - Fast interactive phasing mode.

*Maximum Entropy deconvolution of Lorentzian line-shape, of J-coupling pattern, or of any user-provided function.

*Comprehensive Linear Prediction module, including Burg, LP-SVD, forward and backward methods, etc...

*Integrated processing of NOESY build-up curves, permitting to accurately evaluate distances.

*Automatic peak-picker in 1D 2D and 3D; Automatic peak integrator in 1D and 2D.

*Line fitting of mixed Lorentzian and Gaussian Line Shapes

*Calibration, integration, peak-picking, etc..

*Fast interaction with the mouse on 2D and 3D

*Help for attribution, on screen and on plotter

*Interactive commands for beginners as well as fast entry mode for advanced users

*Complete on-line HELP.

*Comprehensive manual.

*Versatile command parser which permits to build macro commands with alias, tests, local and global variables, loops, graphic interaction and display capabilities, support for data-bases and associative arrays.

*Graphical interface completely modifiable and definable by the user.

*Possibility to run in interactive mode as well as Batch mode (display less).

*The operating system is fully available from Gifa.

Entering the program

You enter the program by typing gifa on your favourite system (don't panic, just type EXIT to get out of it!) . The program should give you a short greeting, the size of the larger data-set, and then respond in the text window with the prompt :

Gifa>

The other method consists in clicking on a button in the graphic interface. The graphic interface consists in sets of related commands, arranged in vertical button boxes, each such boxes being called by clicking the associated button in the menu bar. Each button box can be opened and closed at will.

The two methods are strictly equivalent, graphic buttons are internally associated to commands (or list of commands). One day, you will eventually learn how to do your own buttons.

Entering

Gifa> HELP

at the prompt level will give you the same message. The command HELP is here in uppercase, it can actually be entered also in lowercase, or even in a mixture of upper and lower case letters. In the whole manual, we will use the rule that every built-in Gifa command is given in uppercase. Macros, however have to be typed exactly as defined (this is due to the UNIX file-system), they will always appear in the manual as lower case.

Typing

Gifa> HULP

will give you an error message, since there is no command nor macro named hulp (at least on the distribution kit)!

The HELP command can also be used with a parameter :

Gifa> HELP primer

Some command may require one or several parameters, you will be prompted for such parameters, either in graphic dialogue boxes if the command was entered from a menu, or at the text terminal if the command was typed from it. When entering the prompt level, it is also possible to put the parameter directly after the command on the same line.

For instance, let us try the UNIT command which permits to determine the current unit used on the data-set : PPM, Hertz (as determined form internal parameters) or Index (ranging from 1 to n in the case of a data-set of length n ), or seconds (for time domain data-sets).

Typing

Gifa> UNIT

will prompt you for the unit to use, just typing return will leave the value unchanged.

Typing

Gifa> UNIT H

Will set the current unit to Hertz.

Display and Zooming

These windows can be closed at any time, re-opening them is performed by issuing the correct command either from the prompt or from the menus (see below). Most of these windows can be resized, to the exception of the 2D density display window which has a fixed size of 512 pixels on each axis. The colours in these windows can also be modified with a set of colour commands.

All the spectral windows can be FREEZEd, either by typing the command, or by selecting the entry in the window menu. A frozen window is just a copy of the current window, just staying here for comparison. It is completely passive, and can only be closed or iconified if needed, the content cannot be changed any-more.

The graphic windows are completely optional, and the effect of a command does not depend on the fact that a graphic window is there or not to display the effect.

A control box should also appear at start-up in the upper right corner of the screen. This box holds controls which permits to zoom and adjust the scale of the display. (If this box disappears, or is absent for any reason, you can make it appear again with the ZM command (also in the Display menu)).

To zoom the display, simply click on the graphic window with the left and middle buttons pressed, and draw a rectangle on the display. You can redraw as many time as wished this rectangle. To zoom into the selected region, simply click in this rectangle with the left and right button of the mouse. You can also use the Zoom in and Zoom out buttons in the control box. The spectrum showed in this box, is the complete spectral region, as was dispayed when you clicked on the Catch Spectrum button. The white rectangle in it, shows the current zoom region.

The four little arrows can be used to move around the zoom region. Each arrow will move the selected region by half the size of the zoom box.

There are five controls to adjust the vertical scale used for displaying the spectra. The Reset button will reset the display to the default, (ABSMAX 0 SCALE 1) where the largest peak in the screen in full size. The four other buttons permit to modify the scale value, raising or lowering the SCALE context by factor of 2 and of 1.2. See below for more details on SCALE.

The pop-up menu Dim, can be used to rapidely switch between the 3 working buffers : 1D, 2D and 3D. Finally, the text above the small spectrum is the current coordinates of the mouse, that you get whenever you click in the display.

However it is completely optional, and Gifa can work without any menu bar (even without any graphic window !), or with a completely different graphic environment.

The environment macros are found in the /usr/local/gifa/macro directory. Some macros necessitate additional files for interactive processing or for texts, these files are held into the /usr/local/gifa/macro/gm directory.

If the graphic is missing, try typing the following command env_base.g, which executes the macro which loads the default menu-bar, from which you can add all the specific menus.

Some menus are optional or may not be on screen at the same moment, see the Mode Menu.

Entries followed by 3 dots (...) indicates that some input will be asked to the user by the command.

The name of the entries in the menus have been chosen to ressemble as closely as possible to the command name which would realise the same action. This makes the menus a bit cryptic, but ease the process of learning the commands, which can then be used to extend the capabilities of the program by writing macros. These menus implement most of the actions that you will need in regular processing, however there are many more capabilities in Gifa than the ones which are available from this standard menu interface.

About GIFA

Read...

Convert from UXNMR

File name

Size of data

Quit GIFA

Proc 1D

Proc 2D

Proc 3D

... Advanced proc

...MaxEnt

...Linear Prediction

... Plot

... Peak

... Unix

Disp1D on

By default when entering the program, the DISP1D and DISP2D windows are on but the CDISP2D window is off. This is because the display in contour plot is slower than the density display, and it makes little sense to display a FID in contour plot!

back to stored zoom

Rzoom

Equivalent to the super2d macro

All the processing in Gifa is performed in working buffers. There are 3 main such buffers, the 1D, the 2D and the 3D buffers. The content of the 1D and 2D buffers is directly visualised in the 1D and 2D graphic windows. Only one such working area can be selected at a given time, however switching from one buffer to the other is virtually instantaneous. All commands and actions apply to the currently selected buffer; processing commands (FT, etc..) as well as display commands (SCLAE, ZOOM, etc...).

Get Data

Put Data ...any processing... Get Data

Point

Unit...

Calib...

Select Row

Select Col

Row...

Col...

Apodisation menu

Em...

Gm...

Sin...

Tm...

Correct 1st point

ChSize...

Equivalent to the CHSIZE command.

ZeroFill

ft_Seq

ft_Sim

Ph

Redo Phase

Real

Modulus

Easy 2D

ZeroFill F1 - ZeroFill F2

Burg 2D

ft_Seq (F2)

ft_Sim (F2)

ft_phase_modu (F1)

ft_tppi (F1)

ft_sh (F1)

ft_sh_tppi (F1)

ft_n+p (F1)

Ph in f1 (ph2dc)

Ph in f2 (ph2dr)

Redo Phase F1

Redo Phase F2

Real F12

Modulus

Proj F1

Proj F2

In 3D processing F3 axis always refer to the acquisition axis, F1 refers to the axis which is stored with the slowest increment, and F2 to the intermediate axis. Thus, 3D can be seen a series of F2-F3 planes. Note that this definition depends only on how the data-set was stored, and not on the order of the incremented delays in the sequence.

Naming of planes is done by giving the axis orthogonal to the plane rather than the axes in the planes; for instance the planes holding the F1 and F3 planes are noted F2 planes.

ZeroFill F1

ZeroFill F2

ZeroFill F3

Burg3d

ft_Seq (F3)

ft_Sim (F3)

Phase

Real...

Real F123

Modulus

Display 3D

disp3d on

parameters...

control box

choose zoom...

plane...

diag...

vertint

planeint

Dataset parameters

list all files

disjoin

get plane

get region

3D proc...

BCorr linear

BCorr Spline

BCorr Polyn.

1D Hilbert

IFT CHSIZE(%*2) FT REAL

or

Remove H2O

You should start with a spectrum, phased, baseline corrected, but, ideally, not apodised. You can do processing from an apodised data-set but you will get better results if you start over with a spectrum obtained without any apodisation.

Using this menu, Maximum Entropy can only be applied on a spectrum containing only positive, absorptive spectra.

Deconvolution fct...

Iterations...

Start Iteration

* you don't have a FID on screen

* you don't have realised the previous steps

Restart

remove background...

To fully understand what is going on here, you are supposed to have read the manual (no joking :-). Most (all ?) entries here, are supposed to be applied on untouched (i.e. not apodised) FID.

make FID Cplx

burg extension

stable SVD extension

burg spectrum

FAB-SVD analysis

PKlist

Plot menu

Easy plot

plot?...

Title

Plotaxis F1 - Plotaxis F2

Grid F1 - Grid F2

Page

Cindy...

eval noise

Peak pick (pp)

add a pick

rem a pick

pkclear

Integ

ShowPeaks

PlotPeaks

Show Amoeba

linefit

show linefit

show_fit

residue

PkList

PkRead

PkWrite

pwd - cd... - more... - ls -l

Shell

vi...

vi macro/...

vi ~/macro/...

Commands are presented here ordered by functionality, and oriented toward the command level, in contrast with the previous chapter oriented toward the user interface. Extending the user interface can be simply done by learning and using these commands, and the macro language.

As you have seen if you have been through the primer, Gifa is an interactive program : it waits for commands from the user. Some commands have parameters some don't; some commands may even have a variable number of parameters depending on some context value (it is a so-called context-dependent grammar).

For instance HELP is a regular command, but DISP1D is a context which handles the parameter describing the state of the graphic 1D window. A good example of this distinction is given by the context LB which defines the default value used for exponential broadening, as compared to the related EM command which actually apply this exponential broadening to the current data-set.

Most of the behaviour of the program depends on these internal parameters (contexts). Another example of a context is DIM which describes whether we are working with 1D 2D or 3D data-sets .

For instance, type :

Gifa> DIM 1 ; switches to 1D NMR

Gifa> size ; lists basic parameters

Gifa> DIM 2 ; switches to 2D NMR

Gifa> size ; lists basic parameters

( characters following the semicolon are comments )

The effect of the command size (which lists the basic parameters of the current data-set) depends on the state of the context DIM.

Most contexts have associated Gifa variables which permits to evaluate its value during macro execution. See the chapter on variables for details.

Commands can be issued alone, in which case, the command will prompt you for all the values it needs, proposing default ones. Default values may be kept by hitting the <enter> key, or may be changed by typing new ones. You can also type the parameters on the same line than the command; the effect is then immediate. When using in-line entry, the different item will be separated by blanks.

Several commands can even be typed on a single line, separated with a blank. For instance to get back to 2D display mode, you could either type :

Gifa> DIM 2

Gifa> size

or, on a single line :

Gifa> DIM 2 size

* Some commands prompt for trivial parameters : file name (READ), integer number (DIM with parameter which can be 1, 2 or 3), etc.. Little to say about theese.

* Some commands promt for spectral coordinates. Coordinates are always prompted as INDEX (this could be easily changed in the source, to pompt in the current UNIT), and can be entered in any unit : integer values (terminated or not with a i) for indexes; in Hertz by terminating with a h; in ppm with the p suffix; and finaly in seconds with the s suffix. e.g.

zoom 1 10 10 200 300

zoom 1 10i 10i 200i 300i

zoom 1 8.3p 8.3p 7.5p 6.5p

zoom 1 6000h 6000h 4500h 4000h

or even mixed :

zoom 1 10 10i 7.5p 4000h

actually might defined the same zoom window (values are given as an example)

* Some commands prompt for a direction on the current data-set (for 2D and 3D), in which case, axes are called : F1, F2, (F3 if in 3D), sometime combinaisons are meaningfull : F12, (F13, F23, F123). In 2D, F2 is the classical dimension (associated to t2) and F1 is the non classical (t2). In 3D, F3 is the classical dimension, F1 is the slowest non-classical and F2 is the intermediate one.

* Some commands ask for a parameter per spectral axis, in which case, F1 is always prompted first, then F2 (and finally F3).

* Some commands ask for a list of parameters, and the list has no predefined length : BCORR 1 (which ask for coordinates), FORMBOX which asks for field definitions, etc.. In which case, the list has to be terminated by some caracter. It will be 0 whenever integer values or coordinates are awaited, and it will be a star "*" whenever strings are awaited.

So, to process a data-set with Gifa, you generally load it in memory, do most of your processing, plot it, and optionally store the processed data on a file for later processing. This permits a very fast processing on small every-day data-sets. When a larger data-set necessitates to work on a file, then a set of specialised commands permits to use all the regular commands on file.

Gifa presents several buffers to store the data. Three working buffers are available for respectively 1D, 2D and 3D. These 3 buffers are independent for regular processing. The buffer on which you are working depends on the value of the context DIM which takes the value 1, 2 or 3.

Loading and Saving data-sets : READ, WRITE, READx, WRITEx

Several file format are available directly from within the program (plus the utilities permitting to translate from other file formats). The following format are available : READ or READC (same command) for the standard Gifa cached format, the file is stored in a submatrix format, the parameters are in text format in the header part of the file (can be viewed with more); READH is for the ft-nmr format; READL is for NMR1/NMR2 format; READV is for Varian format. The corresponding write commands are WRITE (or WRITEC) WRITEH and WRITEL (no WRITEV available so far).

Several other file formats are available : READM and WRITEM reads and writes text files, formatted as one line per row for a 2D data-set, and a single line for 1D (not available for 3D data-sets). This format is compatible with the -ascii format of the MATLAB program. Note however that no parameters are stored along with the data, and that the text file might have very long line that will overflow most text editors. READT and WRITET handle data file in generic text format; on entry per line, with a set of parameters; this permits to import and export data from Gifa to any other program. READS and WRITES are special file format stored in compacted text format; this format is totally independent from the machine used, the file thus stored can be read with the Gifa program running on any machine. This permits to share NMR files in a network, for instance a set of different workstations working with NFS on a file server. This format is in text format and can be safely sent on E-Mail (however you should take care not to send too large files, and eventually cut your large files in smaller pieces (size <= 100kbyte)). Finally a READZ WRITEZ format is available, this format make use of Linear Predictive Coding to compress the data before storing (J.Magn.Reson. 1991). The WRITEZ command uses the value of the ORDER context as the length of the Linear Predictive Polynomial (see chapter on Linear Prediction). The default value of 10 seems to be an optimum for most NMR data-sets. The compression is performed with no loss of information, with a compression ratio typically in the 50% - 60%. To be used only on time domain data-sets.

EM is for exponential broadening. The parameter is the broadening applied in Hz. Negative values are possible and are for resolution enhancement (associated with GM). The value used is given by the value in the context LB. In 2D and 3D, will apply a different exponential apodisation on axis. If you do not wish to modify on a given axis, enter a null value.

GM is for Gaussian broadening. The parameter is the broadening applied in Hz. The value used is given by the value in the context GB.

LB and GB are also used in Maximum Entropy processing.

SIN is for a shifted sine-bell. The parameter is the position of the maximum of sine-bell, varying form 0 (pure cosine) to 0.5 (pure sine). The parameter of SIN is not kept in a context.

SQSIN is equivalent to SIN but applies a SQuared SINe-bell.

TM is for trapezoidal windowing, and it uses two parameters which are the coordinates (in points) of the 2 points T1 and T2. The window then goes from 0.0 value at the first point of the data set to 1.0 at T1 and from the 1.0 value at point T2 to 0.0 at the last point plus one of the data set.

In 1D, you can use the sequence :

Gifa> ONE SIN .3 ; or any other apodisation

to visualise the effect of a given filter.

Depending on the spectrometer the data you get should be processed with FT (complex FT) or RFT (real FT) and eventually pre-processed with REVF. REVF actually inverses every 2 points over 4. This has the effect to reduce the time-proportional format used for the seq mode on BRUKER spectrometers (on real data-sets).

On complex data-set it has the effect to put the zero-frequency on the borders of the spectrum (after the FT step!).

The Fourier transforms available are :

FT IFT : complex to complex FT and its inverse

RFT IRFT : real to complex FT and its inverse

FTBIS IFTBIS : complex to real FT and its inverse

The complete set of Fourier transform can also be summarised as follow (C stands for Complex and R for real) :

FIDs Spectra

C ~FT-> C

C <-IFT~ C

R ~RFT-> C

R <-IRFT~ C

C ~FTBIS-> R

C <-IFTBIS~ R

R Does not exist R

The Hilbert transform is simply realised by

IFTBIS FT ; generate a complex data set from a real

IFTBIS PHASE 90 0 FTBIS ; generate the missing imaginary part

IFT FTBIS ; in-place zero filling using Hilbert

; relations

INVF is related to REVF, it inverse every other point in the data set, thus taking the conjugated value on complex data-sets. Because of this, the sequences : INVF FT and FT REVERSE are equivalent. On hypercomplex data (2D) INVF F12 will take the hyperconjugated.

REVERSE simply returns the current spectra left to right.

The type of the data-set (real or complex) is described by the context ITYPE. For 1D, ITYPE is 0 for real data and 1 for complex data. For 2D, ITYPE can takes 4 different values : 0 means real; 1 means complex in the F2 direction; 2 means complex in the F1 direction (I know, this is a bit odd but has to make sense in 1D as well as in 2D); 3 means complex in both directions (so-called Hypercomplex data type). In 3D 1 means complex in F3, 2 complex in F2, 4 complex in F1 and the corresponding sums depending on the hypercomplex state of the data-set. For instance, 7 means that the data-set is complex in all axes.

Certain commands require a specific ITYPE value. For instance FT is available only on complex data sets. An error message will be given if an FT is tried on a real data-set. Note that if the data is complex, the real part is held in odd points of the buffer, the imaginary part is held in the even points.

ITYPE is usually handled automatically by the program, so the user does not need to worry about it. You may however have to change it in certain cases, typically when loading the data-set the first time, when "playing around" with the data-set, or when a "bug" happens in the program (highly unlikely......!?)

HPHASE performs a Hilbert transform in order to create the missing imaginary part, it thus permits to phase a real spectrum by creating the imaginary part on the fly. The sequence IFTBIS FT will create a complex spectrum from a real one (with half the resolution), thus permitting to experiment phase parameters with the PH command. These phase parameters can then be used on the corresponding original real spectrum.

The command MULTDATA, on the other hand, multiplies point by point the content of the current buffer with the content of the DATA buffer. This permits to realise convolution product. When applied on complex (respectively hypercomplex) data-sets, a complex (respectively hypercomplex) product is realised.

Linear mode will then realise a linear regression through the pivots points and remove the linear baseline thus found. If only one point is given, then a horizontal baseline is computed. Spline mode will compute a cubic spline going through the pivot points and remove it from the data set. Spline mode requires at least 3 pivot points to work. BCORR proposes as default values for the index of the pivot points, the last clicked points with the point (the values in the point stack) command; you can thus use the %% syntax.

A third option is available in BCORR, corresponding to polynomial (and related) baseline correction. This last option of the baseline correction is modular. The correction is made in three steps:

*first the signals and the baseline are separated in zones (referred in the following as the first segmentation), this first segmentation is eventually helped by a temporary smoothing of the data,

*these zones are then joined together in several sets of related area (referred in the following as the second segmentation),

*the correction is finally computed.

There are three general parameters :

BLOCBASE : all parameters in point unit are scaled in the ratio of the data set size to this parameter.

BLCITER : the maximum number of iterations for the whole process

BLCW : when the RMS of the correction is lower than BLCW times the RMS of the data, the correction is finished.

There are several commands and parameters to configure the correction :

SMOOTH1 : controls the smoothing of data.

0 : no smoothing.

+1 : moving average of the data set on a window of WINMA points.

+10 : hysteresis smoothing of the data set with the value LEVELHYSTE.

SEGM1 : you can choose the way the first segmentation is done as follows .

0 : without.

1 : with a standard deviation algorithm on the data set.

2 : with a standard deviation algorithm on the first derivative of the data set.

3 : with thresholds on the data set, and on the first and second derivatives.

4 : with a dynamic clusters algorithm.

+10 : with a morphological filtering after the segmentation.

The two parameters used by the standard deviation algorithm are BLCU and BLCV. You should only use BLCV, for example if you increase BLCV you reduce the sensibility of detection in order to correct a dispersive line shape.

The threshold option just remain for historical means, the four thresholds are SDS, SDB, SCB, SCS.

The dynamic clusters algorithm is controlled by four commands :

DCALGO : select the data on which the algorithm operates.

+1 : the algorithm runs on the data set.

+10 : the algorithm runs on the first derivative of the data set.

+100 : the algorithm runs on the second derivative of the data set.

DCDISTANCE :

0 : Norm 1.

1 : Euclidean distance.

DCITER : the maximum number of iterations for the dynamic clusters algorithm.

DCFACTOR : used in a logarithmic scaling of the data set.

Then you can add a morphological filtering either on the baseline selection or on the signal selection by choosing a number of points with MORPHOB and MORPHOS.

SEGM2 : this feature is only useful with a polynomial approximation.

0 : without.

1 : interactive.

2 : automatic.

When you choose an interactive second segmentation, you have to choose one or several areas with the WINDOW command to allow the program to cut the correction in these areas if needed.

The automatic segmentation uses a window, WINSEGM2, and a threshold, LEVELSEGM2.

APPROX : the last step is to choose the way the baseline is estimated.

0 : with ITERMA2 times a moving average filtering on a window of size WINMA2.

1 : with a Legendre polynomial approximation of degree DEGRE.

+10 : with a linear interpolation of signal before approximation.

+100 : with an 'elastic effect' that is a rude way to prevent from burying the weak lines.

There are four special commands that may help you with all these options :

BCORRP0 : restores the initial configuration with a polynomial approximation.

BCORRP1 : enable a configuration with a dynamic clusters segmentation and a moving average approximation.

BCORRP? : lists the current configuration.

BCORRP : a step by step command to choose a set up.

ADDBASE will remove a given systematic offset on the data-set. The command prompts you with the last value computed by EVALN.

SPECW, OFFSET, UNIT, FREQ

The context FREQ holds the basic frequency of the spectrometer (in MHz). It is used to compute ppm from Hz. The context UNIT will tell other commands (POINT, PKLIST, etc...) to choose the unit used. UNIT can take the values INDEX (number of channel) HERTZ (based on SPECW and OFFSET), PPM (HERTZ divided by FREQ), and SECOND(based on SPECW). All other values are invalid.

DISPLAY AND GRAPHIC INTERACTION

DISP1D, DISP2D

The size of the created windows with the DISP2D command, is hard-wired and cannot be modified.

The display is refreshed at only the end of each command line; you can thus avoid useless display of intermediate computation by putting all the related commands on one line.

2D are displayed in density mode. The density mode consists of a colour coding of the value of the points. 64 colours are used, distributed with a constant interval on positive and negative values. Values around zero are coded in black.

The display is computed at the end of the command line. Some point may be skipped when displaying large spectra (typically greater than 4k in 1D, and larger than 512x512 in 2D) but not for plotting. The vertical size of the display is defined by the SCALE context. The display depends also on the ITYPE value; imaginary points are nor displayed.

The scale is computed such that for SCALE=1, the larger point of the spectrum is full-screen. The value of this larger point is held in the ABSMAX context. ABSMAX is recomputed at display time whenever the data actually changed, however it is not recomputed when it is not needed and you can force the computation of ABSMAX by putting its value to 0. The scale being relative, ABSMAX can be modified to compute absolute display and plot by forcing its value to any pre-defined value. This value will not be overridden as long as the data are not actually changed.

To make this long story short, one can say that the point with the value ABSMAX/SCALE will be displayed full screen.

SIGN determined, in 2D or 3D whether only positive points, only negative points or both will displayed.

VHEIGHT is the level to which the zero level will be plotted in 1D display. Unit is in %, 0 will draw at the bottom of the screen/page, 1 at the top. Standard value is 0.3 (30%).

CLEAR context determines if each display will be drawn on the top of the previous one (0 mode) or if the window will be cleared before drawing (1 mode - default mode).

1 2 3 4 5 6 etc...

with LOGA 1.5 levels will be :

1 1.5 2.25 3.375 5.0625 7.59 etc...

LOGA equal 2 corresponds to the BRUKER standard spacing.

When working full spectrum on large data-set a CDISP2D can take too long, and you may wish to stop the display, you can always do it by typing a ^C.

Contour plot display are normally in colours, with a colour code equivalent to the DISP2D mode, however it is possible to switch to a Black and White mode with the CCOLOR context.

The colour table used by the density mode is built when starting the program. The presence of a file called .gifacolor is checked first in the working directory, then in the $HOME directory, then the presence of a file called gifacolor is checked in /usr/local/gifa/com. If one of these file is found, it is used as a list of colours to be used by the density display. The file has one entry per line, first the choice of colours for the pointer, then for the density mode, starting with the large negative value ending with large positive values. Each entry is of the form HUE - SATURATION - INTENSITY. If no file is found, a default set up is used. You will find on the distribution tape a set of small programs that permits to build such custom colour tables. The standard colour table, as well as a Black & White colour table are given as example.

ZOOM is a command which permits to define a zoom window on the data-set in a non graphical way. It is perfectly possible to define a zoom window, even if there is no graphic open. Many commands (LINEFIT, PEAK, etc..) only appliy within the current zoom window

REFMACRO controls whether display will be done at the end of each command line within macro. Default value of 0 means no refreshing during macro execution, which permits much faster execution. If you write interactive macros with graphical display, you should set REFMACRO to 1. It is often useful to change REFMACRO several time within a macro.

CX, CY, ROTATE, PLOTTER, CONFIG

PEN permits to change the active pen. In HP-GL, this is the number of the pen; in Postscript, 8 kind of lines are available :

PCOLOR permits to choose a colour when plotting on a colour Postscript printer. Only the 8 basic Gifa colours are thus available. If you wish to use more exotic colours, you should edit the plot file itself.

PAGE will send the page to the plotter, and eject the page on a plotter.

PLOTOFFSET is the constant offset on x and y axes which is applied for each plots. Each plotting command will see the point at coordinates 0;0 as actually being offsetted from the true 0;0 of the paper with the PLOTOFFSET values. PLOTOFFSET permits to stack different plots on a single sheet.

TITLE will plot the text following the command at coordinates x=0, y=CY+1.

PLOT? will prompt you for all the parameters currently used for plotting.

All these commands will prompt you for an output parameter, entering *PL (or *PLOTTER) will output the plot to the plotter. Entering a file-name will create a file containing the graphic commands for the plotter. If you send several plot commands to the same file, the following commands will be appended to the first one in the plot file, thus permitting to make composite plots on a single sheet. The PAGE command appends the order for page change, send the file to the plotter port, and makes Gifa "forget" about the plot file, thus plotting again on that file will erase the file and start a new plot. FORGET will only makes Gifa forget the file, without sending it to the plotter.

The plot file can also be sent to the plotter by typing at the operating system level :

$gifaplot plot_file plotter_type ( VMS or UNIX)

with plotter_type being either postscript or HP-GL, depending on the type of plot file you have created.

When working in postscript, it is very convenient to use a Display Postscript program to monitor the state of the current plot file.

CX : length in centimetres of a line.

CY : maximum height of a peak in centimetres.

SCALE : scaling applied to the data before plotting, if scale=1 then the larger peak on the surface will be CY high, if scale>1 then clipping will occur.

STDY : each new line is offsetted by STDY centimetres in the Y axis.

STSKIP : every STSKIP line of the data-set will be drawn.

STSHIFT : each new line will be shifted right by STSHIFT points, if negative then the shift is done on the left. (May be fractional).

STSKEW : determines how the horizontal lines are skewed during plot, (if negative skewed to the left and to the right if positive.

STPL? permits to check all the parameters in one command.

On screen stack plots are currently limited to 256x128 points (larger plots generally crashes the graphic).

FILTER, WINDOW

FILTER holds an apodisation function, used with the APPLY FILTER command (only if the FILTER context is set to 2). In 2D or 3D, F1, F2 and F3 domains will be sequential in the buffer. You can design an exotic apodisation function, put it in the FILTER buffer, and use it.

WINDOW is very similar to FILTER as definition, but not as use. WINDOW is the description of valid points within the data-set (more precisely of f(1;<[[sigma]]>)). Thus a null value in WINDOW indicate a point with total uncertainty. WINDOW usually holds 0.0 or 1.0 entries, but any real values are valid though negative values have little meaning. The command WINDOW permits to design the WINDOW function; by resting it to 1.0, or by "digging" holes in it. WINDOW is used by BCORR 3, MAXENT, etc... It is useful also to put to zero a certain region in a data set (for instance the water curtain in 3D).

Other buffers are available, used by the MaxEnt or the line-fitting package, see the specific documentations.

PUT loads the given buffer with the current data-set

GET brings back the given buffer as the current data-set

SHOW displays the given information in the 1D window or in the 2D window

APPLY computes the result of the mathematical operation.

SHOW

GET

PUT

The buffer : can be : APPLY

   WINDOW      window used to compute the chisquare in MaxEnt processing,     *  *  *  *  
               also used by the polynomial mode of BCORR                                  
 FILTER {n }    Generic filter function, also used for MaxEnt Deconvolution   *  *  *  *  
    DATA       data used as a second hand by MaxEnt and Linear Prediction,       *  *     
               also used as a general purpose buffer.                                     
    LAMB       the evolution of Lambda  during MaxEnt iteration               *  *        
     ENT       the evolution of  Entropy during MaxEnt iteration              *  *        
     CHI       the evolution of  ChiSquare during MaxEnt iteration            *  *        
    STEP       the evolution of  Step during MaxEnt iteration                 *  *        
     SUM       the evolution of Sum of point of Image during MaxEnt           *  *        
               iteration                                                                  
    CONV       the evolution of Convergence during MaxEnt iteration           *  *        
   RESIDUE     The residue after a MaxEnt run                                 *  *        
   LINEFIT     The result of the last line fitting                            *  *        
   AMOEBA      the contours used for integration during the last 2D Paris     *  *  *     
               integration                                                                
     FT        The causal Fourier transform (FTBIS) of the current data-set   *           
   CURRENT     the current data-set  (useful for comparing with SHOW)         *           
 PLANE Fi n    the nth plane of the 3D data-set, along axis Fi (F1, F2 or           *     
               F3)                                                                        
    ROW n      the nth row of the 2D data-set                                       *     
    COL n      the nth col of the 2D data-set                                       *     

The command SHOW uses, for some option, the value of the context SCOLOR to determine the colour to be used by the display.

The two commands GET DATA and PUT DATA permit to put aside a data set for a while and getting back to it very quickly. Note however that the size of the larger data-set that can be put aside this way is only a fourth of the larger Gifa data-set.

The PUT FILTER command (to be issued in 1D mode) has a syntax which depends on the setting of the NCHANNEL context. NCHANNEL describe how many independent channels will be considered in the filter window. If NCHANNEL is 1, then the current data-set will become the filter function. If NCHANNEL is greater than 1, then the command will prompt you for which channel to load the filter function in. This permits to build a 2D or 3D filter function (in which case, the i^th channel corresponds to the i^th dimension); or to build multichannel deconvolution functions for MaxEnt. If the channel index 0 is given, then the action is as in 1D.

The command PUT permits to put the content of one lower dimension buffer into a higher data-set. You can thus PUT ROW index or PUT COL index in 2D or PUT PLANE index in 3D :

Gifa> ROW 1 DIM 1 MULT 0.5 DIM 2 PUT ROW 1

will divide by 2 the first row of the data-set.

Introduction to 2D and 3D processing

This design is optimum whenever the data-set is small enough to be kept in memory without even using the disk (up to 2 Mega (2D : 1Kx2K or 3D : 128x128x128) points on a typical system). The main drawback is that there is a definitive upper-limit for the size of the data-set. This limit depends on your system, but is typically 4 Mega (2D : 2Kx2K or 3D : 128x128x256) on most small to middle work-stations, and 16 Mega (2D : 4Kx4K or 3D : 256x256x256) on larger machines. This setting can easily be modified by recompiling the program. If you need to work on a larger data-set, you will have to resort to the cache memory system, see below.

READL, READH, READV, WRITEL, WRITEH, ADD, ADDDATE, SIZE, LIST, ADDBASE, MULT, DSA, ABS, ONE, ZERO, PLUS, MINUS, ZM, PEAK, INTEG, LINEFIT

The following commands will now take more parameters instead of 1. In this case, in 2D the first one always refer to the F1 dimension (non-classical dimension, displayed vertically) and the second to the F2 dimension (classical dimension, displayed horizontally) ; in 3D the order will be F1, F2, F3.

CHSIZE, GB, LB, EM, GM, SPECW, OFFSET, EXTRACT, ZOOM, EVALN, SMOOTH, MEDIAN

The following commands will prompt you for an extra parameter which will describe which dimension the process should be applied : F1 means F1 dimension, F2 means F2 dimension, (in 3D F3 means F3 dimension) and whenever possible (noted (*) in the present list), combination F12 and F13 F23 F123 in 3D :

FT(*), IFT(*), RFT(*), IRFT(*), FTBIS(*), IFTBIS(*), PHASE, HPHASE, REVF(*), REVERSE(*), SIN(*), SQSIN(*), SWA(*),TM(*), USWA(*), BCORR

RZOOM (2D)

In 3D, the projection along one axis, onto a plane will be computed and put into the 2D buffer

Gifa> FT F2 FLIP FT F1

will perform the classical complex Fourier Transform (not hypercomplex). These commands are used when processing phase modulated data-sets. The sequence :

Gifa> REVF F2 RFT F2 FLIP REVF F1 INVF FT F1 FLOP MODULUS

will perform the computation of a phase-modulated data-set acquired on a BRUKER spectrometer in sequential mode.

In 3D, you can exchange the imaginary part of the F3 axis with the F1 or F2 axis.

Transposition is not a natural step when working with Gifa, all the processing can always be performed randomly in any axis.

The transpose process is performed in-place and is very time consuming. On typical systems it is probably faster not to transpose when processing the data set. On very small system with very limited physical memory, it may be faster to use transpose. Try comparing

Gifa> FT F2 FT F1 ; normal processing

to

Gifa> FT F2 TRANSPOSE FT F2 ; transpose during process

on your system

Gifa> plane F2 index

will select the plane holding the F1 and F3 dimension, at coordinates F2=index.

Plane by Plane

Plotting planes extracted from a 3D consists simply in selecting planes with the PLANE command, and plotting them as 2D with PLOT. For instance the simple macro :

for i = 1 to si_1_3d

plane F1 $i plot *pl page *pl

endfor

would do the job.

DISP3D, REF3D

CX, CY, CZ, ALPHA, BETA, GAMA, AXIS3D, ZNOT, OFFSET3D, SCALE3D

DISP3D?, CHECK3D

Buttons are available with the CHECK3D command, which permits to directly choose some typical points of view (along each axis, along the main 3D diagonal of the cube). See above the definition of the box in the Graphic User Interface manual part.

WORKING ON FILE RATHER THAN IN MEMORY

Introduction to the cache system

This is performed through a cache-memory system that is implemented into the Gifa program. This features has the double advantage of permitting the processing of very large data-set (no limitation in size, as far as the software is concerned), and to speed-up the processing of the processing of large data-sets that can be done otherwise in-memory.

In the previous version of the cache (Cache version 1.0, in Gifa 3.x and in pre-release of Gifa 4.0), the blocks were of a fixed size of 4096 words (16 kbytes) corresponding to 16x16x16 in 3D, to 64x64 in 2D and to 4k in 1D. This is no longer true, in the present version (Cache version 2.0, since Gifa 4.0),, the blocks are adapted to the experiment and to the computer. This means that the block may take any value, optimised for the current hard-ware (typically 4kbytes and 16 kbytes), and that the division of the blocks will depend on the sizes of the experiment, in order to optimise access speed in all the spectroscopic dimensions.

The standard format features also a header which holds all the parameters of the data (such as dimensionality, sizes, spectral widths, etc...). This header is in text format, and can easily be displayed with a more command. The user can easily add his own information in the header with the GETHEADER PUTHEADER commands. The header is of a fixed size equal to the size of a data block. The cache system can be used with several files in the same time.

Cache memory access is much faster than a disk access. The block structure of the file speeds up the processing of large data sets. For instance to access 2 successive planes of a 3D, the first plane will be loaded from the disk, and then the second will be subsequently held into the cache memory. There is no real limitation of the size that the cache system may handle, however each file opened with the cache system will use room in the computer memory allowing to fit several line (plane) of the 2D (3D) experiment.

It is important to note that writing onto the cache is not equivalent to writing onto disk. There is some mechanism, that will store on disk the content of modified block when needed; but the content of the file is not warranted when working through the cache system (this is very different from the WRITE command). This has no effect when working from within Gifa itself, since all file access will go through the cache system that will insure the coherence of the data. However it may have effect in certain cases such as : *accessing the file from another program (may be another Gifa); *power failure of the computer; *a bug in Gifa (?).

When needed, it is possible to "flush" the cache and to copy to disk all the modified blocks with the commands FLUSH and FLUSHCACHE.

JOIN, DISJOIN, LISTFILEC

dataset, GETHEADER, PUTHEADER

GETC, PUTC

GETC loads data from the file to the memory; PUTC copies the content of the memory to the file. Both commands have a similar syntax. They permit to handle data areas as well as complete lines, planes and cubes. The action taken depends on the dimensionality of the JOINed file as well as the value of DIM in the Gifa working context.

dimensionality of the JOINed file :

value of dim :           1D            2D                     3D                     
            1D         1D area         1D area                1D area                
            2D     not applicable      2D area                2D area                
            3D     not applicable      not applicable         3D area                

GETC / PUTC low up

in 1D, where low and up determines the area to load, or

GETC / PUTC axis ... index ... low up ...

in 2D and 3D where the number of axes, indexes and coordinates depends on the kind of transfer.

See per command manual for the detailed syntax.

The SHOWC command does not actually load the whole data-set in memory for displaying, plays game with the cache memory. This is why it is a little slower than the regular display.

This command is used in the super1d and super2d macros which permit to overlay several display on screen.

FLUSH flushes onto disk the modified data corresponding the currently JOINed file. FLUSHCACHE will flush all the file currently JOINed.

is equivalent to proc2d, but processes the 3D in a plane wise manner. Be careful that the command you enter will be in 2D mode, and that whatever plane you choose for the processing of the 3D, the commands will refer to the plane as F1, F2.

For instance, you can handle a full memory 2D data-set if you do not wish to do 3D. However, when working in 3D, if you zero-fill a 2D plane extracted from the 3D, over the protected area size for 2D, you will destroy a part of the 3D buffer. You will sometime get the question : 'This will overflow the xx buffer, Ok?' when there is any risk of destroying one of the buffer. This question is not asked during macro execution, where you are supposed to know what you are doing.

With the current set-up, the size of the protected 3D area is typically f(1;2) of the size of the main buffer, the larger protected 2D is f(1;4) of the larger 3D, and the protected 1D is f(1;4) of the larger 2D.

On another hand, certain operations in Gifa need large work storage, and will use the top of the main buffer for this; thus being incompatible with a large data-set. These commands are : Maximum Entropy, the linear prediction package, the automatic baseline correction BCORR 3 and the PUT DATA and GET DATA operations. However the amount of memory used depends on the command. The Maximum Entropy and Linear Prediction (but not the BURG, READC and WRITEC commands which are in-place) will use the f(3;4) of the main buffer so only f(1;4) will be left for regular processing; this limitation is independent from the size of the larger data-set to be processed by MaxEnt which is f(1;8) of the main buffer. The PUT DATA and GET DATA command will use f(1;2) of the main buffer. The BCOR 3 command will need only f(1;8) on the top of the main buffer. With all these commands the remaining of the main buffer can be safely used. If you try one of these command with a too large data-set in the buffer, the data-set will be corrupted on the overlapping region.

The Gifa program has a complete capability to detect, integrate, line fit and manipulate peaks.

This facility is based on an internal structure holding informations on the last peak detected. This internal structure is called the peak-table. 3 such peak tables are simultaneously held in the program, respectively for the 1D, 2D and 3D data sets. Peak tables can be loaded, listed, read and written onto disk, and peaks can be selectively removed form the table. The commands relative to the peak table always refer to the current peak table, as defined with the DIM context.

The peak table is used by the peak-picker module, integrator module, the line fitting module and the linear prediction module.

One way of doing is by searching for the largest and smallest points in the data-set with the MAX command, which set the default values for MINIMAX. However, the smallest value has usually to be reset by the user to a more realistic value. For instance you can compute the mean level of noise with the EVALN command, and enter the noise level time a given scalar as the minimum intensity for a peak :

point ,select an empty area

max evaln %% minimax (4*$noise) % , loads the value

The command PEAK will then find all the local maxima which lies within the upper and lower bounds in the data-set, and load the peak table. The peak table will restrict its search to the currently displayed spectrum, thus permitting to perform a peak-picking on a restraint area of the spectrum by zooming at it. When using PEAK in 2D and 3D, you will be prompted for a packing radius. Giving a non-zero value has the effect of "packing" or "linking" all the peaks which are less than n points apart from each other into the larger one, thus removing the entries of the smaller ones from the peak output.

The macro pp has been designed to help in this process.

PKLIST i j will list the contents of the current peak table to the screen from peak i to peak j. Thus PKLIST %% will list the complete peak table. The origin of the peak table (picker, integrator, LP, etc...) is given, and all the descriptors of each peak. The unit used for the coordinates of the peaks depends on the context UNIT. This command can be successfully with the CONNECT - DISCONNECT commands to generate listings.

The amoeba is determined by three criteria, with four parameters associated : RATIO, SLOPE, THRESHOLD, and RADIUS. The first criterion that will trigger will determine where the extension of the amoeba should stop.

RATIO triggers when the ratio between the largest point in the peak and the current evaluated point gets below RATIO.

SLOPE triggers when the slope changes. A value of 0 will be triggered anytime the slope changes from negative to positive (thus starting to climb on another peak); a larger value will permit more freedom on the slope.

THRESHOLD will trigger whenever the evaluated point is below the (absolute) value of THRESHOLD.

RADIUS determines the maximum extent of the amoeba from the central peak.

When using the integrator, the noise level and the systematic offset of the surface should have been evaluated with the EVALN commands

There are two additional contexts that determine fully the PARIS module : SIGN_PEAK tells the peak-picker if the peaks are to be found either as positive peaks or as negatives peaks. ZERO_QU tells the integrator that the amoebae should be computed on the absolute value of the surface, (but the integrator will still work on the normal surface). This is very useful when working on NOESY spectra where there is zero-quantum coherences signals (the integration of which is zero).

The SHOW AMOEBA command shows the amoebae that have been found at the last integration step.

The MSKINTEG will integrate the peaks as define by the current peak table and mask (amoeba) matrix. This command permits to integrate several experiments using the same amoeba definition. The amoeba matrix can moved around with the PUT and GET commands. The 2 macro mskread and mskwrite permit to read and write directly amoeba matrices along with peak tables.

The amoeba can also be modified with the MODIFY_AMOEBA command which permits to set a given pixel to a given peak, or to remove it from the amoeba definition.

Where Y is the recomputed spectrum, y is the current spectrum and [[sigma]] is the variance of the noise, estimated from the NOISE command. Thus a correct fit corresponds to a final equal to 1.

Results can be examine with the standard commands SHOW LINEFIT or SHOWPEAKS. As an addition, macros called show_fit and plot_fit are provided, which permit to display/plot a composite display of the current data set with the fitted lines superimposed on the spectrum.

The command :

put data get linefit mult -1 adddata

Permits to obtain the residue (that part of the data which is not fitted), the command

get data

returning to the current data-set.

INT1D

SIMU, SIMUN, ONE, ZERO

SIMUN is different, it permits to simulate only one line, but this line is added to the current data-set, with all the current parameters (spectral width, sizes, etc...). The command ADDNOISE permits to add a Gaussian noise to the current data-set.

MESSAGE is used in macro, it is equivalent to PRINT, except that the string will be output to the user only if no parameters are available on the call line. It is thus nearly equivalent to

if (!$arg) PRINT text

However, it is different in the sense that the string will be presented in the graphic dialogue box when the macro is called from a menu button.

eg :

printf "Size of the data-set \t%d x %d\n" $si1_2d $si2_2d *

These macros are implemented by calling 'awk' (a UNIX facility) with the SH command. This implies that : i) they are a bit slow; ii) they may fail (SH fails when the memory is low on the machine); iii) errors in formats will be detected by awk, not by Gifa (nawk has mush better error messages that the old awk); iv) type man awk to get information on the available formats.

HELP

Gifa> sh "ls -l /usr/data"

You can also type SH alone, this has the effect of creating a sub process at the operating system level (csh is used ), you then get back to Gifa by loging out ( ^D on UNIX).

Using SH, several macros have been created that mimic UNIX : more, rm, ls, vi, pwd, etc... There are also two special editing command : vip will edit in your $HOME/macro directory, and vim in /usr/local/gifa/macro

sh 'cd dir'

*literal are as typed:

chsize

*literal string are enclosed within single (') or double(") quotes:

'a string' or "another string" or "yet an'other valid string"

*The special character % (to be used only as a parameter for a command) takes the place of the default value of the command:

EM %

*The special string %% takes the place of the whole series of all the default values of the remaining parameters of the command :

ZOOM 1 % % % % and ZOOM 1 %% are equivalent

Many commands know how to deal with this syntax, for instance BCOOR 1/2 needs a series of point to compute the baseline correction. If you have previously clicked on a set of points on the data, you will be prompted for the values corresponding to these points. So

bcorr 1 1 %%

will just do the work.

The baseline correction interactive macros use this feature.

*variables are substituted before use (more about this later):

$variable1

*expressions, enclosed within parentheses, are evaluated before use (more about this later) :

( 2*(cos(3) + 1))

*any of the preceding syntaxes may be preceded with a < symbol. In which case the input is interpreted as a file name, and the parameters takes the value of the next line read in the file (if already OPENed). A complete line is read at each time.

Each of these syntax can be used in any places; however, a single word cannot match a series of words :

These are valid syntax :

row $i ; select row i

row (%+1) ; select the next row

col (2*$i +1) ; select col 2i+1

set apod = 'sin' $apod 0.5 ; perform sin 0.5

read ("/usr" // $user // $exp) ; read a file

("simu" // "noe") ; execute the command SIMUNOE

set f = test open $f row <$f ; select the row whose index ; is found in file called test

These are invalid syntax :

set apod = 'sin 0.5' $apod

a single word (here 'sin 0.5') cannot be used to match several words

EM 1+2

the parenthesis are needed for expression to be evaluated

etc...

A line cannot be longer than 256 characters, otherwise the end the line will be lost. If a longer line is needed, a continuation sign is available : \

e.g.

Gifa> print 'A line cannot be very long' print \

\Gifa> 'But can be continued' print 'as many time as you wish'

Gifa> set b = 'hello world' set c = 3

Gifa> set d := 'hello mom' ; other syntax, see below

Variables are then just used by prefixing the name with a $ :

Gifa> em $c print $b

Variables can be used anywhere a regular entry is needed. Variables are not typed, but contain always a string. The maximum string is currently of 256 characters. The string is interpreted as a number when needed. Variable names are not case sensitive, the name is a maximum of 31 characters long; and must be built from purely alpha-numeric characters only (including the underscore : _ ). The number of available variables is limited at compile time (and reported by the command CONFIG, and variable $VAR_MAX (see below)), but a larger table can easily be built by recompilation if needed.

Associative arrays can be built using the construction [index] :

Gifa> set d[$k] = (cos($k/10))

Associative arrays means that each entry is created when needed, entries do not have to be sequential, and the index does not even have to be integer :

$d[1] ; $d[3] ; $d[$z] ; $d['foo bar']

is a valid array. Associative arrays are coming from the standard UNIX program awk, search for a manual of this program if you some help with associative arrays. The function nextlm() permits to go through all the entries of a given array (see below).

Variables are allocated the first time they are set; referencing a variable not yet allocated generate an error. Variable are automatically deallocated when exiting the macro; they cannot be accessed by any other macros that would be executed during the life of the variable. In other words, variables have local scope, and are volatile (dynamically allocated and removed) (be careful, variables before v4.0 had always global scope !).

Variables created at interactive level (not within a macro) have a special treatment : their life will be as long as the program (unless an UNSET command is explicitly used), and they can be accessed by any other macro : they are static and have global scope.

If you which to create such a static variable from a macro (useful to remember parameters from one call to the other), you can use the following syntax :

set d := 'this variable is static'

If d was already declared as volatile previously in the macro, the preceding command has the effect of creating a new variable, called d, but in the static storage, independent of the volatile d.

SET varname = value ; set (and create if needed) the variable

SET var2 = value ; create and set a global variable

UNSET varname ; remove the variable from the table

MUNSET list of vars finishing with a *

; removes all the variables in the list.

DUMP ; dump the content of all currently defined

; variables

The format of the DUMP is : name of the variable ; context of the variable : (20 is static, 21 to 29 are macro call levels) ; content of the variable.

Using DUMP you will find that there might be entries in the variable table that do not correspond to user variables. This is due to the fact that the parser uses this table for particular use (dbm arrays, positions of label, location of WHILE, FOR controls). This entries have different formats from the user variables, thus cannot be mistaken with them. Some of these entries holds binary data that might disturb the terminal when using the DUMP command.

dbopen array_name file_name

will associate a pseudo associative array with the dbm files of base name : file_name. The file is created if it does not exist yet. No actual variable array_name is created, but each operation on it is performed on the dbm file.

DBCLOSE closes the file and forget about the array array_name .

( 2*(5-1)) (cos($i)) are examples of expressions. Expressions can be used whenever a Gifa input is needed (command as well as parameters). Expressions must fit on one line (i.e. 256 characters long), continuation mark cannot be used within expressions.

* the regular 4 operations : + - / * e.g. : (2*3 - 1)

* the modulo function : % (12 % 5)

* the power ^ operator (3^2.1)

* the regular mathematical functions : sqrt(x) cos(x) sin (x) atan(x) log(x) exp(x) abs(x) int(x) max(x,y) min(x,y)

* the special function power2(n) will have the value of the closest power of 2 below or equal to the number n : power2(130) will be 128 (=2⁷)

* the concatenation operator : ( 'string1' // "string2" )

* the formatting operator : ; equivalent to // ' ' //

("Value is:" ; $a) is equivalent to ("Value is:" ; // ' ' // $a)

* the alphanumeric operators : toupper(st) put string in upper case

tolower(st) put string in lower case

sp(i) generates a string of i blanks

len(st) is the length of the string

index(st1,st2) is the position of st2 located in st1, 0 if not present

subst(st,i,j) is the substring from st, starting at i, ending at j

head(st) will be the first word in string st (blank separated)

tail(st) will be the string st but the first word.

headx(st,c) and tailx(st,c) are equivalent to head and tail but

the character c is used rather than blank.

* the numeral comparison operators : == != < > <= and >= for comparing numbers : ($x<=0.5)

* the string comparison s= (equal) and s! (different) for comparing strings : ($s s= 'name')

* the logical operators : | (or) and & (and) : (($x<=0.5)&($s s= 'name'))

* the not operation : ! : (!($i==1)) (!$arg)

* the function eof(file_name) will be true if the last input from file file_name (with <file_name) had reached the end of the file, will be false otherwise.

* the function dbm(array_name) is true if array_name is bound to a dbm file with the DBOPEN command

* the function exist(var_name) will be true if var_name is a user variable either local or global. e.g.

if (exist("i")) set j = ($i+1)

j is computed only if $i exists as a variable.

The special syntax (exist("foo[]")) checks wheter the array foo exists with at least one index. It works both for regular and dbm arrays.

* the functions va1d(i), val2d(i,j) and val3d(i,j,k) returns the value of the content of the main Gifa working buffers. In 2D i and j are the index in F1 and F2 respectively, in 3D in F1, F2 and F3. This replaces the old $VAL[] construct.

* the function itoh(index,dim,axis), htoi(hertz,dim,axis), itop(index,dim,axis), ptoi(ppm,dim,axis), htop(hertz dim, axis) and ptoh(ppm,dim,axis) perform unit conversion. Respectively : index to hertz and back; index to ppm and back; hertz to ppm and back.

For each function, index, ppm or hertz is the value to be converted, dim is the dimension to use (1, 2 or 3) and axis is the axis to use, depending on which spectral widths and frequencies you want to use for the conversion.

* the next element function : nextlm. If i is an entry in the associative array $array, the construction nextlm(array,i) will have the value of the next available entry. The end of the array is notified with an empty string. The series is also initialised with an empty string. The series is gone through in the internal order which is not related neither to the input order nor the sequential order. For instance the following macro will print all the entries of the array $table :

set $index = (nextlm('table',' '))

while ($index s! ' ')

print ($index // ' : ' // $table[$index])

set $index = (nextlm('table',$index))

endwhile

Check also the macro tunset, which permits to remove all the entries of an array.

When evaluating expressions, all the internal computations are not typed and performed on strings. This permits to mix integer and string freely. Thus the following expressions are perfectly valid :

( cos(1) // 'a string' // ($i==1))

( toupper($file // ($i+1)) )

( log ('0.1') )

Introduction to the control language

Gifa> @file_name

or simply

Gifa> file_name

In UNIX the macro name is the file name, sometime names with a .g extension are chosen (used to be .gif before the v4 version, but has been changed to separate from the popular graphic file format .gif). Any characters (but the blank) can be used in macro name, so ../test/my_macro or /usr/local/gifa/macro/startup.g are valid names.

A macro consists of a series of regular Gifa commands used as in the interactive mode. Up to 9 recursive calls may be nested (i.e. you can call a macro from within a macro, down to 9 nested levels). The macro execution can always be stopped with the ^C command.

Note that

Gifa> @file_name

...any personal set-up

disp1d 1

/usr/local/gifa/macro/startup.g ; to be sure to have general set-up

You will find a comprehensive library of such macros in the /usr/local/gifa/macro sub-directory of the distribution kit.

will set the value of the ith point in the current buffer to val. The number of parameters for determining the point to be set depends on the value of DIM.

Similarly SETPEAK permits to change the coordinate of a peak table entry.

FOR var_name = initial TO final { STEP step}

.. some Gifa code

ENDFOR

This construction permits to write loops. The variable called var_name, will be created local to the macro if it does not yet exist, set to the value initial, and incremented by 1 for each loop. The increment can be different from 1 (but always numeric) with the optional field STEP step. step can even be negative, in which case the variable will be decremented. In any case, the test performed to determine whether the loop is finished or not is (var_name > final) if step is positive or (var_name < final) if step is negative.

WHILE some_value_to_be_evaluated

.. some Gifa code

ENDWHILE

The Gifa code will executed as long as some_value_to_be_evaluated is true (is non zero). The value to be evaluated can be a variable or a complex evaluated expression into parentheses.

The IF command has two distinctive syntaxes : a one-line IF without possible nesting nor else; and a complete IF .. THEN construct with ELSIF and ELSE possibilities.

The multi-line IF is as follow :

IF test THEN

..commands on several lines

{ ELSIF test2 THEN

..commands } (eventually many exclusive tests )

{ ELSE (default case)

..commands }

ENDIF

The different commands will executed conditionally on the value of the tests. Any non-zero value is considered as true. If may be nested, with no limit on the number of nesting.

The one-line IF is as follow :

IF logical_value ...remaining of the line ...

All the commands on the remaining of the command line are executed only if logical_value holds true (is non-zero).

examples :

IF ($X =< 0) GOTO SKIP

print 'Hello' IF ($ITYPE_1D == 1) set x = ($x+1)

IF (!eof(input)) print 'Still reading the file' \

set line = (%+1) \

IF ($line<$linemax) goto continue

tests to be used are described in the "evaluated expression" paragraph.

GOTO label

will redirect the execution of the macro to the symbol =label appearing somewhere else in the file.

Example

=loop

...any kind of processing...

goto loop

GOTO should not be used to jump into FOR or WHILE loops, nor into IF .. THEN structures, Unpredictable execution will occur.

All these commands may freely nested. However, except for GOTO and the one-line IF, these commands (FOR, ENDFOR, WHILE, ENDWHILE, =label) should appear alone on one line, with no code preceding nor following the command (or the label), but eventually followed by a comment.

In Progress : 0%....25%....50%....75%....100%

with a dot every 1/2O^th of the process

INITINPROGRESS tells Gifa how many iterations are to go, INPROGRESS actually does the display. INPROGRESS can be called at any rate, there is no need to do arithmetic to call INPROGRESS.

It is to note that, for a clean result, no terminal output should be performed during a INITINPROGRESS INPROGESS pair

Example :

set max = 1000

initinprogress $max

for i = 1 to $max

... do something

inprogress $i

* if a command misses a parameter, the user will be prompt for it, even if the macro is called deep in a nested loop. The user will be prompted with the current value. e.g.

print 'Enter new size' chsize

(actually the message is not really needed, since the command CHSIZE will issue one)

If the macro is called from the graphic interface (with BUTTONBOX), either directly or indirectly called, a dialogue box will be used to prompt the user for the value, the message from the command (here chsize) will be in the dialogue box.

* by the same token, it is possible to assign the input into a variable :

set b = 10 print 'Enter new value' set b =

The user here will be prompted with the value 10 as default for b.

The command MESSAGE permits to put the message in the dialogue box if the macro is called from a menu button, and on the terminal if called from the prompt. Thus this is a better construct :

set b = 10 message 'Enter new value' set b =

For instance, if the file test_arg is as follow :

; to test argument passing

print $_

set b = $_ print (2*$b)

set c = $_

the following call

test_arg hello 3

will produce the following output

hello

6

and will prompt for the value to be applied to c. Thus $_ can be used to both the command line or the user, much in the same way as regular Gifa commands do. It is even possible to have an optional message, depending whether there is a parameter available or not, with the variable $arg :

if (!$arg) print 'Enter new value'

set b = $_

The MESSAGE command, has similar built-in mechanism, the string is sent to the user only if no parameters are available on the calling line. But it is better to use the MESSAGE command, since the message will then go to a dialogue box if the macro is called from the graphic interface.

message 'Enter new value'

set b = $_

sh 'more text_file' ; UNIX

As an example the 2D Fourier Transform could be written

; do the 2D FT in macro (specially silly),

if ($dim != 2) error 'Only in 2D' ; do some checking

if ($itype_2d != 3) error 'Only on hypercomplex data-sets'

if ($si1_2d*$si2_2d) > 1024k error 'too big for 4 times z-f'

print 'Processing in F2'

chsize % (2*power2(%)) ; zero-filling in F2

initinprogress $si1_2d ; set up in progress bar

for i = 1 to $si1_2d ; loop over rows

row $i dim 1 ; get ith row in 1D buffer

ft ; process it

dim 2 put row $i ; put it back

inprogress $i ; display in progress bar

endfor

print 'Processing in F1'

chsize (2*power2(%)) % ; zero-filling in F1

initinprogress $si2_2d

for i = 1 to $si2_2d ; loop over cols

col $i dim 1 ; get ith col in 1D buffer

ft ; process it

dim 2 put col $i ; put it back

inprogress $i

endfor

exit

but don't try that one for real processing, it would be really slow!

A more useful example :

; do contour plotting in colours, 1 colour per level

; using scale, level and loga

if ($level>8) error 'Too many levels, should be <= 8'

set loc_lev = $level level 1

set loc_sca = $scale

for i = 1 to $level

pen $i % plot %

if ($loga!=1) scale (%/$loga)

if ($loga==1) scale ( (%*$i) / ($i+1))

endfor

pen 1 % page %

scale $loc_sca level $loc_lev

exit

Another example showing how you can build a special apodisation function in the window buffer and then use it :

; this macro builds a cosine roll-off apodisation function

; and applies it to the current data set

; works in 1D !

; in 2D, build the WINDOW only once and loop APPLY WINDOW on the 2D

put data ; keep data aside

chsize (%/8) one sqsin 0

chsize (%*8) addbase 1 mult -1 reverse ; build apodisation

put window

get data apply window ; apply apodisation

Here is a small (silly) interactive example :

; to compute the square root of a given number

sh 'more intro.txt' ; some greeting message'

set i = 1 ;i should be set here for the following test to work!

while ($i <> 0)

print 'Enter your number (0 to end)'

set i = 0 ; pre-set the value and ask for it

set i =

if ($i>0) then

print ('Square root of';$i;'is';sqrt($i))

elsif ($i<0) then

print 'No real square root !'

endif

endwhile

exit

BUTTONBOX, CLOSEBOX

Any legal command can be used to be associated with a given button, a built-in command as well as a macro, and will be executed as if entered form the terminal. So the WHILE, FOR, IF .. THEN, GOTO commands are not available but the IF .. any_command syntax is valid. The action of the command in independent from the way it is called, except for the user prompting for values, which is performed with dialogue boxes in the case of a command called from a button.

Example given :

BUTTONBOX "my first menu" \

Hello "print 'Hello World'" \

separator \

Dim dim \

"Test Dim" "if ($dim == 2) print 'We are in 2D'" \

Back ("read" ; $name) \

Reread "read $name" \

*

Which gives :

Note :

* How the command should on a single line, but how the continuation sign (\) can be used

* How the quotes are needed only to isolate field with blanks in it, for button names as well as commands (Hello Dim)

* How single and double quotes can be mixed to build composite commands (Hello)

* How the on-line IF can be used (Test Dim)

* How evaluated expression are evaluated when building the menu if not within quotes : Back reads the file which was last read when building the menu (the expression is evaluated when building the menu), Reread reads the file which is last read at the time the command is executed (Back Reread)

The command CLOSEBOX closes the menu bar and all the associated menus. It is equivalent to closing the menu bar from the close box.

message "Enter new size" set newsize := $_

will react as follow :

nothing will appear if called with a parameter :

example 256

the user will be prompted if called without parameters :

example

the user will be prompted in a dialogue box if the macro is called without parameters from a menu button.

DIALOGBOX permits to build sophisticated dialogue boxes, several fields can be built into the dialogue box, that the user has to fill-up. Each filed is internally associated to a Gifa variable, that the remain of the macro processes. The command appears as follow :

DIALOGBOX [series of entry] *

Each entry consists of a name, that appears as such in the dialogue box, and of a type for the field. Types can be : message, string, int, real, file, enum.

message type consists of a string that is displayed on the form and permits to put text in it.

The others type of field have two other entries which give the name of the associated variable and its default value. These types correspond to editable fields that the user has to fill-up. string, int, real correspond to string, real values or integer values respectively; file corresponds to a file-name entry, and presents a small additional button in the dialogue box, which permits to pop-up a standard Motif file selection box.

The last type : enum realises a pop-up menu, for an enumerated choice. It needs an additional entry which described the list of choice. Example given :

Dialogbox "my first dialogue" \

"Enter below the file name to work on" message \

"Enter file name" file var_file $name \

separator \

"Action to apply" enum "Read,Write" var_act % \

*

$var_act $var_file

This macro will build a dialogue box with 2 editable entries : (filename and action) and will apply the action to the selected file if the user clicks on Ok.

Note :

* How the command should on a single line, but how the continuation sign (\) can be used

* The separator special field which builds a thin line in the dialogue box

* How the enumerated list is comma separated

* How the default value can be anything, here a Gifa internal variable ($name), and the default prompted value (%). In this last case, the default prompted value will be the value of the variable itself if the variable exists before the dialogue is built. If this is not the case, it will be the first entry for enum, 0 or real and int and the empty string for string and file.

* How the returned values are usual variables, and can be used for anything (here even as Gifa commands)

FORMBOX is the static version of DIALOGBOX. It builds a form that will remain after the completion of the command (as BUTTONBOX does) and will survive as long as the user does not explicitly closes it. FORMBOX needs an additional field (the callback) which describe the Gifa command to be executed when the user clicks on the Ok or Apply buttons. Apart from this, the definition of FORMBOX is strictly equivalent to that of DIALOGBOX. If not global, a variable associated to a field in a FORMBOX is local to the FORMBOX, and cannot be accessed in any other macros but the callback line. Example given :

Formbox "my first Form" \

"print ('Hello';$y_name) print ('today it is';$the_wet) " \

"Enter informations below" message \

"Your name : " string y_name "unknown" \

"The weather today :" \

enum "Sunny,Rainy,Cold,Stormy,Terrible" the_wet % \

*

Note :

* How the form variables can be used in the callback, in expression, as parameters for other commands

* Check other points in DIALOGBOX and BUTTONBOX

Typical error conditions are :

* unknown command *wrong parameter for a command (e.g. FT F3 in 2D; SIN 1; FT on real data, etc.. ). * A impossible READx or WRITEx is tried (e.g. READ DATA.001 and DATA.001 does not exist). * mistyping a parameter (e.g. EM 0,5 instead of 0.5 ), * a ^C was typed by the user, * an ERROR command was issued.

If the error occurs when the command was executed from a menu button, a alert box will be displayed.

It is perfectly possible to create files in order to run the program in background.

On UNIX machines, type a file containing the command as you would type them and just start Gifa by "piping" the file as standard input, and the output on another file. The & sign run the process in background :

% gifa < name_of_the_COM_file > process.out &

Again, DO NOT forget the final EXIT. Also you may experience problems if you use interactive shell commands such as 'vi' or even 'more'.

When running in batch mode it is usually useless (though not forbidden) to activate the display. However if you want to have Gifa running while you are not logged on, you should choose a graphic-less mode. This mode is entered if there is no X_window DISPLAY available. For instance with

unsetenv DISPLAY

Do not forget to adapt a special startup.g macro (for instance in the current disrectory) in order not to launch the standard graphic environment (which would give an error anyway).

Q : How do I refere to Gifa in my publication ?

Delsuc, M.A., 1989. A New Maximum Entropy Processing Algorithm, with Applications to Nuclear Magnetic Resonance Experiments. In: J.Skilling (Ed.), Maximum Entropy and Bayesian Methods, Cambridge 1988, pp. 285-290, Kluwer Academic, Dordrecht.

which describes the GIFA MaxEnt algorithm/implementation

Pons, J.L., Malliavin, T.E. and Delsuc, M.A., submitted. Gifa V4 : a complete package for NMR data-set processing.

which will describe Gifa (if ever accepted)

You may also use the following references :

J-Deconvolution: the Application of the Maximum Entropy Processing to the Deconvolution of Coupling Patterns in NMR. Marc A.Delsuc and George C.Levy. J.Magn.Reson. 76 p306-315 (1988)

for the J-Deconvolution method

A New Spectral Representation for 2D NMR Spectra: The Hypercomplex Numbers. Marc A.Delsuc. J.Magn.Reson. 77, p119-124 (1988)

for the Hyper Complex Fourier transform

Application of Maximum Entropy Methods to NMR Spectra of Proteins. M.A.Delsuc, M.Robin, C.Van Heijnoort, C.B.Reisdorf, E.Guittet and J.Y.Lallemand. NATO WorkShop Il Ciocco. (1990)

generic text on use of MaxEnt

"Optimized Acquisition and Processing Scheme in 3D NMR Spectroscopy" M.Robin, M.A.Delsuc, E.Guittet and J.Y.Lallemand J.Magn.Reson. 92 645-650 (1991) 

MaxEnt in 3D

"Compression of Multi-dimensionnal NMR Data-sets" Thérèse E.Malliavin, Marc A.Delsuc, Jean-Y.Lallemand, J.Magn.Reson. 94 p 630-634 (1991)

the READZ WRITEZ commands

"Convolution Difference in the Time Domain, and its Application to 2D NMR" P.L.Fortier, M.A.Delsuc, E.Guittet, P.Kahn and J.Y.Lallemand J.Magn.Reson. 95 p166-169 (1991)

the SMOOTH command

"Le traitement des données en RMN" M.A.Delsuc, P.L.Fortier, C. van Heijenoort, T.Malliavin, M.Robin, A.Rouh, les Cahiers IMABIO 3 p49-61 (1992)

generic text on use of MaxEnt

"Computation of Redfield Matrix Element from Incomplete NOESY data-sets" Thérèse E.Malliavin, Marc A. Delsuc and Jean Y.Lallemand. J.Bio.NMR. 2 p 349-360 (1992)

the Build-up curve processing part

"Accurate estimation of inter-atomic distances in large proteins by NMR" Christine Reisdorf, Thérèse .Malliavin et Marc A.Delsuc; Biochimie 74 p809-813 (1992)

another reference

"Baseline correction of FT NMR Spectra : An Approach in terms of classification" Alain Rouh, Marc-André Delsuc, Gilles Bertrand, and Jean-Yves Lallemand, J.Magn.Reson. A-102 p357-359 (1993)

The BCORR 3 command

Q : I get the message - startup.g : command unknown - ?

You did not connect correctly to an X-server display. Gifa is perfectly able to run without X-window, but obviously, all the graphic commands won't work. In the case described here, the standard startup.g macro stops when trying to set-up the graphic environment. To set-up the X-window environment, do (in csh) :

setenv DISPLAY the_name_of_your_X-terminal:0.0

if you use a remote work-station for displaying, check that you enabled the remote display by doing :

xhost +.

Q : I get the message - Cannot open the gifa.log file - ?

Gifa cannot create the journaling file in several cases :

o a gifa.log file is already present in your HOME. This happens when you choose to keep the file when exiting, if a gifa is already running for the same account, or if a previous run of gifa exited with a crash.

o the disk is full, or your quota is exhausted

Q : Why are spectra completely shifted in super1d/super2d

Q : How do I transfer data from my spectrometer to Gifa ?

Varian

Bruker DMX - AMX

Bruker AM/WM

using NMRLink

using Bruknet

using Lightnet transfer

Other cases

* The simplest way is to write Ascii files, and load them with the READT command. Use the WRITET command to get an example of the correct format (most parameters are optional).

* If you use MATLAB, there is a READM command for you.

These command use alternate buffers which are not available because of the size of the current data-set. You can : i) choose a bigger version of the program (there should be three in the distribution) memory allocation is static in Gifa. ii) choose another algorithm. For instance remember that

chsize (%*2) ft phase x y real

and

ft phase x y ift ftbis

Q : Why am I sometimes prompted for the overflow and sometimes not ?

Q : My spectra show up completely scrambled after FT ?

- throw those points awy with a lshift (leads to not-so-nice baselines)

- append this non-causal part at the end of the FID (a bit complicated to do)

- process as usal and then apply a ~25000 degrees first order phase correction. Formally equivalent to the former, but much simpler to do.

There is a complete discution of this problem at : gopher://gopher.nmrfam.wisc.edu/00/digfilt2 due to W. M. Westler and F. Abildgaard.

with the parameter X [0.0 0.5] and N points to process

s = 2*(1-x)

w = PI/((N-1)*s)

phi = PI*(s-1)/s

after the

SIN x command, the ith point of the current buffer is multiplied by :

SIN(i) = sin( (i-1)*w + phi ) with i : 1..N

Q : set si1_2d = 2048 does not work

set si1_2d = 2048

Q : my log file does not go away when I exit with : exit n

Q : What is the Gifa data format

There are also data format which are easier to handle for a small program :

ft-nmr kind or format (READH); ascii format (READT); matlab format (READM).

In first place I want to thank T.Malliavin, J.L.Pons, M.Robin, A.Rouh and V.Stoven who have developped large parts of Gifa.

I also want to thank all those who helped me in this project (either contributing small parts of it, helping the port to new architectures, or giving access to their machine):

for the development and port to new platforms : J.Basque, Y.Bernier, F.Billois, F.Bontemps, L.Caussade, F.Capozzi, G.Deléage, C.van Heijenoort, C.Labadie, F.Lacourt, L.Ladavière, S.Lavaite, R.Legoas, C.Pruvost, G.Salnikov, G.Zhu (and the ones I forget ! ).

And all the people which helped me by enjoying, using and debugging it.

I hope that you will have fun, and enjoy working with the Gifa program. In any case don't hesitate to contact me (bug reports and propositions are specially welcomed).

Marc-André DELSUC.

mad@cbs.univ-montp1.fr