WIND Installation Guide - Installing the Build Distributions

(WIND Documentation Home Page) (WIND User's Guide) (GMAN User's Guide) (MADCAP User's Guide) (CFPOST User's Guide) (WIND Utilities) (Common File User's Guide) (WIND Installation Guide) (WIND Developer's Reference) (Guidelines Documents)

(Overview) (Obtaining the WIND Code and Tools) (Installing the Application Distributions) (Installing the Build Distributions) (Porting WIND to a New UNIX Platform) (WIND at NASA Glenn (GRC only))

If pre-compiled executables for the WIND code and/or the tools are not available for the platform you'll be running on, you'll need to install the build distribution. This section describes the procedure for UNIX systems.

Building the WIND Code

Makefiles are distributed with the WIND build distribution for the following platform, operating system, and CPU combinations.

Compaq Tru64 Unix multi-processor Alpha processors
Convex
Cray
Hewlett-Packard
- Exemplar CSPP, PA-8000 processor
- HP-UX 9.x, PA-7200 processor
- HP-UX 10.x, PA-8000 processor
- HP-UX 11.x, multi-processing, PA-8500 processor
IBM RS6000, single- and multi-processing RS64 and PC600 processors
Linux, single- and multi-processing x86 processors
Silicon Graphics
- IRIX 5.x, R4400 processor
- IRIX 6.x, single- and multi-processing, R4400, R5000, R8000, R10000, R12000, and R14000 processors
Sun SunOS 5.x (Solaris 7+), single- and multi-processing SPARC4U processors

[For parallel operation on SGI systems running IRIX 6.2 through 6.5, the WIND code being run on the master processor must be built using the MIPSpro 7.2 (or later) compilers. Beta runs have determined that if WIND (and PVM) on the master is built using the MIPSpro 7.1 compilers, all zones will (improperly) be assigned to whatever host is listed first in the .mpc file. If WIND (and PVM) on the master is built using the MIPSpro 7.2 (or later) compilers, everything works as expected, even if the WIND (and PVM) executable being run on the workers is built with the 7.1 compilers. Earlier versions of IRIX and the MIPSpro compilers have not been tested.]

If you need to build the code for a platform not listed above, you'll need to first create the appropriate makefiles, using the existing ones as a starting point. See the section Porting WIND to a New UNIX Platform for further information. The NPARC Alliance User Support Team (nparc-support@info.arnold.af.mil, or (931) 454-7885) may also be able to provide guidance when creating and naming new makefiles.

Assuming the appropriate makefiles exist, after downloading the gzip'ed tar files, the recommended procedure is described below. Note that steps 4 through 6 can be avoided by installing a WIND application distribution (even if it doesn't include the pre-compiled executable). The WIND build distribution is a complete package, however, and, using the following procedure, a working system can be constructed from it alone.

Put the gzip'ed tar file containing the WIND build distribution into an appropriate directory.
In that directory, unpack the file by doing:
```
   gunzip -c filename | tar xvf -
```
where filename is the file name, including the .tar.gz extension. This creates a directory named wind-dev containing the WIND source code.
Check to see if the CFDROOT, SYSTEM, and SYSTEM_CPU variables have been set to appropriate values, by doing
```
   printenv CFDROOT
   printenv SYSTEM
   printenv SYSTEM_CPU
```
If all three are correctly set, skip ahead to step 7.
If you're using the csh or tcsh shell, edit the file dir_name/wind-dev/bin/cfd.login, where dir_name is the name of the directory used in step 1, to modify the definition of CFDROOT as follows:
```
   if (! "$?CFDROOT") then
   #=BEGROOT=
     setenv CFDROOT "dir_name/wind-dev"
   #=ENDROOT=
   endif
```
Similarly, bash, ksh, or sh users would edit the file dir_name/wind-dev/bin/cfd.profile to modify the definition of CFDROOT to:
```
   if [ ! "$CFDROOT" ] ; then
   #=BEGROOT=
     CFDROOT="dir_name/wind-dev" 
   #=ENDROOT=
     export CFDROOT
   fi
```
Next, csh and tcsh users must edit the .login file in their home directory and add the following line:
```
   source dir_name/wind-dev/bin/cfd.login
```
where again dir_name is the name of the directory used in step 1. Similarly, bash, ksh, and sh users must edit their .profile file and add the following line:
```
   . dir_name/wind-dev/bin/cfd.profile
```
This causes the contents of the cfd.login (or cfd.profile) file to be executed automatically at login time to set up the environment variables CFDROOT, SYSTEM, and SYSTEM_CPU, that are required for installing and running WIND, and to modify your PATH to include the location of the WIND executable.
At this point, log out and log back in to execute your .login or .profile file (depending on your login shell). Alternatively, in your home directory execute (for csh and tcsh users)
```
   source .login
```
or (for sh and ksh users)
```
   . .profile
```
Either way, return to step 3.
Define the environment variable WIND_DEV as the location of the directory containing the top-level Makefile. If in step 1 the WIND build distribution was unpacked in the directory /usr/local/wind, for example, csh and tcsh users would do
```
   setenv WIND_DEV /usr/local/wind/wind-dev
```
cd into the wind-dev directory
```
   cd wind-dev
```
The default values in the configuration files should be sufficient to produce an executable on most well-configured systems (assuming that compilers are installed). The primary exception to this is Linux, which does not have a "default" Fortran 90/95 compiler. Another potential problem is the location of the MPI libraries, which needs to be specified if you wish to use MPI for parallel runs. To be safe, review the contents of the following files or parts of files, where SYSTEM and SYSTEM_CPU correspond to the type of system/OS and CPU being used. [Several systems use a generic makefile and use links to create the specific file for your system. For example, on an SGI R12000 multi-processing system running IRIX 6.5, Makefile.include.SGIMP6.5.R12000.opt will be a link to Makefile.include.SGI6.R12000.opt.]
All the options in these files should be reviewed, but pay special attention to the items noted below.
- Makefile.configure
  - If you're compiling on a multi-processor system with MPI message passing available, change the definition of USE_MPI from NO to YES. This will link in the MPI libraries, allowing the use of MPI message passing for parallel processing. Note, though, that because WIND uses dynamically-linked libraries, an executable created with USE_MPI equal to YES will not run on multi-processor systems without MPI.
  - If you'll never be running parallel jobs using PVM message passing, change the definition of USE_PVM from YES to NO.
- source/Makefile.user
- makefiles/Makefile.include.SYSTEM.SYSTEM_CPU.xxx, where xxx corresponds to opt, dbx, pure, or check.
  - Check the definition of CPP, which is the full path name for the C pre-processor cpp, to make sure it is correct for your system. You can locate cpp using the whereis command, at least on SGI and Sun systems.
```
   whereis -b cpp
```
  - For Linux systems, you will most likely have to change the definition of the Fortran compiler used in the FC, F90, and LD variables. Note all three require a Fortran 90/95 compiler.
  - If you're compiling on a multi-processor system with MPI message passing, check the definition of MPILIBS, and modify it if necessary to use a different version or a non-standard location.
  - The makefiles for SGI R12000 and R14000 systems include a -r12000 option in the definition of ABI, which requires the MIPSpro 7.3 (or later) compilers. If you're using the 7.2 compilers, either remove the -r12000 option, or change it to -r10000.
- makefiles/pvm_conf/SYSTEM.SYSTEM_CPU.def.xxx, where xxx corresponds to opt, dbx, or pure.
  - In the definition of ARCHCFLAGS, the -DRSHCOMMAND option sets the full path name of the "remote shell" command (normally rsh, remsh, or ssh) to be used for parallel operation using PVM message passing. It must be set correctly if WIND is to be run in parallel mode using PVM.
  - The makefiles for SGI R12000 and R14000 systems include a -r12000 option in the definitions of ARCHCFLAGS and ARCHFFLAGS, which requires the MIPSpro 7.3 (or later) compilers. If you're using the 7.2 compilers, either remove the -r12000 option, or change it to -r10000.
From the wind-dev directory, run make to create all the required libraries and executables for running the WIND code. To capture the output from make in the file make.log for later examination if something goes wrong, in addition to displaying it at the terminal, csh and tcsh users should do
```
   make opt |& tee make.log
```
and sh and ksh users should do
```
   make opt 2>&1 | tee make.log
```
If you have a previous installation of WIND that you wish to update (i.e., CFDROOT points to some other directory than the one you are building from), you will need to install the WIND amd PVM executables. To do that, issue the commands
```
   make install
   make install_scripts
   make copy_pvm
```
The first two commands copy the WIND executable to $CFDROOT/SYSTEM/CPU/bin and the WIND run scripts to $CFDROOT/bin. The third copies the PVM executables and libraries to $CFDROOT/pvm/SYSTEM/CPU, some PVM include files to $CFDROOT/pvm/include, and PVM scripts to $CFDROOT/pvm/lib. The parameters SYSTEM and CPU correspond to the platform/operating system and the CPU type, respectively. For example, if the code is being built on an SGI workstation running IRIX 6.5, with an R10000 CPU, SYSTEM and CPU will be SGI6.5 and R10000, respectively.
If this is a new installation, it would probably be best to log out and log back in before running WIND. This executes the shell start-up scripts, modifying the PATH environment variable to include the newly-created location for the WIND executable.

Building the Tools

Makefiles are distributed with the tools build distributions for the the same platforms supported by the WIND build distribution. Unlike the WIND build distribution, in order to obtain the source for all the tools several downloads are required. The smaller tools are all bundled together and may be acquired from the "Downloads" page of the "Tools Makefiles" project. GMAN, CFPOST, and MADCAP are normally downloaded separately from their respective "Downloads" pages. Note that the Project Names for these are "gmanpre", "cfpost_pre", and "Madcap production", respectively.

Each build distribution is designed to be a completely independent package, so that the tools can be built without requiring any additional files from IVMS. [There is one minor exception to this, for CFPOST, described below in step 10.] Thus, one could have separate directory trees for the WIND build distribution and each of the tools build distributions. This would lead to a great deal of duplication, however. Therefore, the build distributions are designed to overlay one another. The following instructions assume that all the tools are being built in the same tree.

Place all the source packages in the same directory. If you have already built the WIND solver, the directory above wind-dev is the best place, in order to minimize duplication.
Unpack the archives for the tools you wish to compile by doing:
```
   gunzip -c filename | tar xvf -
```
This places the source for the tools in directories under wind-dev/tools-dev.
Verify that the CFDROOT, SYSTEM, and SYSTEM_CPU environment variables, are correctly defined, as described in steps 3-6 in the procedure for building the WIND code.
Check to see if the TOOLSROOT environment variable is properly set, by doing:
```
   printenv TOOLSROOT
```
If it is, skip ahead to step 8.
If you're using the csh or tcsh shell, edit the file dir_name/wind-dev/tools-dev/bin/tools.login, where dir_name is the name of the directory used in step 1, to modify the definition of TOOLSROOT as follows:
```
   if (! "$?TOOLSROOT") then
   #=BEGROOT=
     setenv TOOLSROOT "dir_name/wind-dev/tools-dev"
   #=ENDROOT=
   endif
```
Similarly, bash, ksh, or sh users would edit the file dir_name/wind-dev/tools-dev/bin/tools.profile to modify the definition of TOOLSROOT to:
```
   if [ ! "$TOOLSROOT" ] ; then
   #=BEGROOT=
     TOOLSROOT="dir_name/wind-dev/tools-dev" 
   #=ENDROOT=
     export TOOLSROOT
   fi
```
Next, csh and tcsh users must edit the .login file in their home directory and add the following line:
```
   source dir_name/wind-dev/tools-dev/bin/tools.login
```
where again dir_name is the name of the directory used in step 1. Similarly, bash, ksh, and sh users must edit their .profile file and add the following line:
```
   . dir_name/wind-dev/tools-dev/bin/tools.profile
```
This causes the contents of the tools.login (or tools.profile) file to be executed automatically at login time to set up the environment variable TOOLSROOT, and to modify your PATH to include the location of the tools executables.
At this point, log out and log back in to execute your .login or .profile file (depending on your login shell). Alternatively, in your home directory execute (for csh and tcsh users)
```
   source .login
```
or (for sh and ksh users)
```
   . .profile
```
Either way, return to step 4.
Define the environment variable WIND_DEV as the location of the directory containing the top-level Makefile. If in step 1 the tools build distributions were unpacked in the directory /usr/local/wind, for example, csh and tcsh users would do
```
   setenv WIND_DEV /usr/local/wind/wind-dev
```
Most systems other than Linux should be able to use the default values in the configuration files without problem. On Linux systems, it is likely that the definitions related to the Fortran compiler will have to be changed. To be safe, check the following files to be sure they contain information that is appropriate for your system. (See the notes for step 9 in the procedure for building the WIND code).
- Makefile.configure
- makefiles/Makefile.include.SYSTEM.SYSTEM_CPU.opt
- makefiles/pvm_conf/SYSTEM.SYSTEM_CPU.def.opt
- tools-dev/Makefile
- tools-dev/Makedefs.SYSTEM
- If GMAN is being built: tools-dev/gmanpre/Makedefs.SYSTEM
- If CFPOST is being built: tools-dev/cfpost_pre/Makedefs.SYSTEM
- If MADCAP is being built: tools-dev/libmadcap/Makedefs.SYSTEM and tools-dev/madcapprod/Makedefs.SYSTEM
- If GMAN, CFPOST, or MADCAP is being built: tools-dev/libmdgl/SYSTEM.mkf
In the wind-dev directory, run make to create all the required libraries and executables for all the tools for which you have installed source. To capture the output from make in the file make_tools.log for later examination if something goes wrong, in addition to displaying it at the terminal, csh and tcsh users should do
```
   make all_tools |& tee make_tools.log
```
and sh and ksh users should do
```
   make all_tools 2>&1 | tee make_tools.log
```
You can also compile tools individually, by doing
```
   make tool_name
```
where tool_name is the name of the tool. Note that the names to be used for GMAN, CFPOST, and MADCAP are gmanpre, cfpost_pre, and madcapprod, respectively.
If CFPOST is being built individually, the MADCAP library must be present, either as source code or as a previously-compiled object library. This can be satisfied in a couple of different ways.
- If MADCAP is also to be built, unpack it in step 2 at the same time as the archives for the other tools that are being built.
- If MADCAP is not being built, download the MADCAP library source code from IVMS (the Project Name is "Madcap production Library"), and unpack it, in the same directory as the rest of the tools, before building CFPOST.
If you have a previous installation of the tools that you wish to update (i.e., TOOLSROOT points to some other directory than the one you are building from), you will need to install the tools executables by doing
```
   make install_tools
```
This copies the tools executables to $TOOLSROOT/SYSTEM/CPU/bin, where SYSTEM and CPU correspond to the platform/operating system and the CPU type, as described in step 11 in the procedure for building the WIND code.
If this is a new installation, it would probably be best to log out and log back in again before running any of the WIND tools. This executes the shell start-up scripts, modifying the PATH environment variable to include the newly-created location for the tools executables.

Note that the build procedure for the tools is somewhat less mature than the WIND build process. Please report problems to the NPARC Alliance support team at nparc-support@info.arnold.af.mil or (931) 454-7885.