In order for the program to set-up its globals please use the 'matmap.m'
to start the program. This will add all paths to your environment, so you
can work with the program in any directory. You probably want to work from
the directory in which you stored the data, as no datapaths are included 
in the datafiles.

Currently there is one directory that contains the latest program files:
  /mom/u/jeroen/matmap         - For general usage

In order to start the program use the 'matmap.m' script. This should do all
the paths for you and setup the global parameters. Until now that is the only
thing the startup script does. In the future the script may execute some 
other initialization scripts as well. Anyway it will be the only central startup
script in the program. It is written in such that it does not matter from which 
directory you start the script, as it traces back its own directory. Hence, you
should not relocate the script as it considers its own path as the main directory
for the matmap toolbox. 

Thence thee startup sequence is the following start matlab

> matlab

and then run the startup script

>> cd /mom/u/jeroen/matmap/
>> matmap

This should display you a welcome message and some recent notes on changes in the program
if any are present at least.
 
From this point you got two choices:

a) Using predefined scripts to do you signal processing. You should view these scripts
as little programs that guide you through the signal processing stage. Normally they
will guide you through the process of loading files, doing some processing and saving 
the files again with the processed data.

In order view which scripts are available use 'scriptListScripts'. It will give you an
overview of the scripts made so far. In order to further improve the matlab processing
new kinds of scripts may be required and any suggestions for new scripts are welcome.

Use help  to retrieve the latest information on the script. By typing the 
name of the script in the commandline will start the script. Scripts are designed for 
sequentially processing many timeseries-datafiles. Normally the script explains its
purpose and lets you go through a variety of the input menus to specify your wishes and
then uses this input to process all the files you specified at once. 

b) Using the functions build in the toolbox. In this documentation you will find a complete
overview of the functions available. Suggestions for new functions are welcome as well.

PROGRAM SETUP
The matmap program is not a real program in a sense that you run it and requests information
and processes the files for you. To be more specific the program consists of a large number 
of small script files which will do a small amount of signal processing. The idea is to 
provide the user with a databank of functions that work closely together and can be
expanded upon individual wishes. On top of this databank of functions several general 
functions have been designed called 'scripts'. These scripts make use of the underlying
functions and guide you through specific signal-processing jobs. You could regard these
scripts as little programs that run within the environment. The aim of these scripts is
to make it easy to process a large amount of data in a similar manner. The function as
well as a template for programming more scripts of a similar nature.


FUNCTIONS
The program consists of a library of functions grouped into different classes. Each class
is given its own subdirectory in the matmap-directory. In order to locate functions within
the program tree the name of the function starts with this directory name. For instance the
activationmap script is called 'scriptActivationMap'. So you know this m-file resides in the
'script'-directory and that the function is intended as a script. It also helps you locate 
functions, for instance if you are looking for a certain io-function, you type io and press
 matlab will show you all m-files in its search-path-directories which will start with
io.


GLOBALS
The program uses several globals to store the data. This reduces the amount of memory used
and allows you to use a kind of pointer to the data-structure. For instance, take the 
timeseries data, when it is loaded, the data is stored in one of the cells of the global TS.
Each of the cells of this global serve as a point in memory to store timeseries data. When 
loading for instance 'test.tsdf' the function will return the index of the cell where the 
timeseries was loaded, e.g.

>> index = ioReadTS('test.tsdf');
>> TS{index}  
>> TS{index}.numleads

This will load the data into the cell array called TS. Here index is the number of the cell
used to store the data in. The second command just displays the contents of the cell with
the number index. Hence in a sense index is a pointer to a position in the cell-array. The
third command will give you the number of leads of this particular timeseries.

All fields in these globals are structured arrays and can contain various fields all describing
one aspect of the timeseries. Note that not every cell needs to contain the same amount of
information. For instance when no fiducials are associated with the timeseries the field
'fids' which describes the fiducials is not present. 

A similar global exists for storing geometry called GEOM.