The software has been known to work on Linux/Intel, Linux/Alpha, OSF1/Alpha, and Irix/MIPS. For non-Linux systems, only the propreitary compilers have been tested. For Linux systems, the standard flags work only with gcc and g77, though with a bit of work (particularly in the loading stage) you might be able to get it to work with f77/f2c. Even though it has been tested only on the Intel and Alpha architectures, it should work on any machine using gcc and g77 (though the performance might not be the greatest).
The memory requirements are minimal for the most part.
The shell scripts in RAMBIN rely on tcsh. If you don't
have tcsh, you should either install it, or change the
scripts to call csh instead. As easier solution would be to
link tcsh to csh.
The entire distribution is available as a single tar and gzipped file.
Uncompress (gunzip) and unpack (tar -xvf) the
distribution, preferably under /usr/local/packages. It will
create a directory called rambin. All code is in the
respective directories under rambin/src. Documentation is in
rambin/doc, and library stuff (see the directory) is in
rambin/lib.
The executables are in rambin/bin/architecture
and the platform independent shell scripts are in
rambin/bin/scripts. Four platforms are currently supported
and the corresponding directory names are: linux_ix86,
linux_alpha, osf1_alpha and irix_mips. By
executing the appropriate script at startup (see below), the path will
be set to point to the directory containing the corresponding
executables for a given platform. This system differs from the one in
traditional Unix systems where a single bin directory
contains all the executables for a given platform (and the
distributions themselves are tailored individually for each platform).
The reason to do it differently here is because in the "heavy numbers"
world, people tend to use all the available CPU they can get generally
mixing various platforms. Therefore it makes more sense to combine
executables for different platforms in one central location (as users
will generally have only one central home directory for many different
platforms).
The executables are compiled statically with default parametres.
This may result in the files being bigger, but I think it's worth it
given the uncertainty associated with using shared libraries (it will
also run faster and, in my field of research, every second counts!).
Linux on the Alpha boxes can run executables statically compiled using
Digital Unix compilers, so by default, the path setting for the
executable directory on a Linux/Alpha machine is
rambin/bin/osf1_alpha. If, for some reason, you want to
compile on a Linux/Alpha machine, or want to use gcc/g77 compiled
executables on a Linux/Alpha box, you just have to edit
rambin/bin/scripts/setup_environment and recompile.
If you've installed the set of programs in
/usr/local/packages/rambin, and you're happy with the defaults (see
rambin/src/common/defines.h), then there's little you need to
do. Simply add the following two lines to your ~/.tcshrc
source /usr/local/packages/rambin/bin/scripts/setup_environment
source /usr/local/packages/rambin/bin/scripts/onrambin
Then type in:
source ~/.tcshrc
You should then be able to access all the programs in the suite after
typing rehash. The executables are compiled using flags that
I think are fairly optimal. If, for whatever reasons, the pre-compiled
executables are not present (this may be the case for non-default
distributions), or if you just want to be on the safe side and
recompile in your environment, then follow the instructions
below.
If you're not happy with the defaults (including the file
locations), then you need to edit rambin/src/common/defines.h,
rambin/bin/scripts/setup_environment, and
rambin/bin/scripts/onrambin. The files are fairly
self-explantory and it shouldn't be too hard to edit them. You may
also need to edit the mkall file in the individual source
directories, which exists to handle special situations.
Once you've edited the necessary files, type:
source /usr/local/packages/rambin/bin/scripts/setup_environment
source /usr/local/packages/rambin/bin/scripts/onrambin
in tcsh. Then cd to rambin/bin/scripts and
type:
install_rambin
This will re-compile and re-install all the programs with the new set
of parametres. install_rambin is generally clever enough to
actually modify the path names in the rambin/src/defines.h
file and the mkall scripts based on what you set the value of
RAMBIN_ROOT in rambin/bin/scripts/onrambin. If all
you do is change the default path in the onrambin script,
then the above command is all you should need to execute for a
complete re-compilation.
At the time of writing, most of the programs in the
RAMBIN distribution (except for
text2html) don't use any hardcoded filenames. So you
should be able to place the executables anywhere without recompiling.
But this may not necessarily hold in the future for certain other
programs that are added to this distribution.
Once the compilation is finished, add the above two
source commands to your ~/.tcshrc. You should then
be able to access all the programs in the suite after typing
rehash.
To re-compile specific programs in the suite, goto the appropriate
directory and see if there is an entry in the file mkall for
that program. If there is, then the command to use is "mkall
program-name. Otherwise, "make
program-name" should work.
If you've installed the RAMP suite of programs, then you just need
to source the setup_environment script only once (in either
distribution).
tcsh
If you're using a login shell other than tcsh (such as
ksh, bash, or sh), you will need to use the
rambin/bin/scripts/onrambin.sh script in a similar manner
described above to set up the environment and the paths (i.e., it
should be called during the startup of your login). This script has
not been tested and cannot be used to recompile the executables in the
RAMBIN suite. To recompile, you must enter tcsh and compile
using the process described above. Once the executables are created,
setting up the path to point to them is trivial.