The Scientific Software Design Repository
=========================================

Overview
--------
This repository contains modern Fortran  and C++ codes first published in the textbook 
Scientific Software Design: The Object-Oriented Way by Damian Rouson, Jim Xia, and
Xiaofeng Xu (Cambridge University Press, 2011).  Updated versions of this repository
can be obtained via git as follows:

  git clone https://github.com/sourceryinstitute/Scientific-Software-Design.git

A less-frequently updated version of this code archive also resides at 
http://wwww.cambridge.org/Rouson via the "Resources" link.

Organization
------------
The codes are in the ssdSource directory and organized into subdirectories named 
after the chapter in which the code can be found.  The ssdSource directoy holds a 
CMake project (http://www.cmake.org). The buildScripts directory contains CMake 
commands for each supported compiler.  The ssdBuild directory, if present, can be 
used for building all of the executables in an automated fashion.  (If ssdBuild 
does not exist, create it or a directory with the name of your choice at the same 
level as the buildScripts directory before proceeding to the "Building" section 
below.)

Building
--------
If you are building inside the HPCLinux distribution available at 
http://www.hpclinux.org, please enter the command "source ./intel.sh" inside the
Scientific-Software-Design directory before continuing.

The preferred method for compiling the code in this repository relies upon the 
automated, open-source CMake build system.  CMake is available for multiple operating
systems at http://www.cmake.org.  CMake can also be installed automatically via 
package management software such as Macports for OS X or yum or apt-get for Linux.  
After installing CMake, set your current directory to this archive's ssdBuild 
subdirectory and run the build script corresponding to your compiler (after editing 
the script to update its details to match your configuration) using a command such as

cd ssdBuild
../buildScript/gnu-compilers-cmake.sh
make
make test

The above commands would use the GNU Fortran, C and C++ compilers to build the 
executable files and would test each executable and report on the success of each 
test.  Alternatively, one can build just a given chapter's code.  For example, to
build the Chapter 3 examples only, enter the following commands:

../buildScript/gnu-compilers-cmake.sh
cd chapter03
make

The aforementioned editing of the script must include providing a path to the LAPACK
library (http://www.netlib.org/lapack/), which is required to build code in Chapter 9.

Most folders also contain a Makefile for building with Unix-like make utilities.
Because it requires a great deal more effort to maintain Makefiles relative to the 
effort of maintaining CMake files, we make no promise that the Makefiles will always
be maintained and up-to-date -- hence the recommendation that CMake is the preferred
method for building the archive.

Most subdirectories in this archive also contain Makefiles that can be used to compile
the code on platforms with the "make" utility 
(http://en.wikipedia.org/wiki/Make_(software)).  We deprecate the use of these 
Makefiles because of the amount of effort that would be required to keep them 
up-to-date and the number of files users must customize to build the full archive.  

Compiler Prerequisites
----------------------
This archive makes extensive use of the explicit support for object-oriented 
programming in the Fortran 2003 standard (and Fortran 2008 in one example in Chapter
12).  As of November 2013, six compilers nominally support all of the Fortran 2003
features employed in this code archive:
  1. IBM XL (xlf),
  2. The Cray Compiler Environment (cce),
  3. Portland Group (pgfortran),
  4. Numerical Algorithms Group (nagfor)
  5. Intel (ifort)
  6. GNU (gfortran)
Most compilers not listed above do not support a sufficient number of Fortran 2003
features to compile most code in the book.  If your compiler is listed above but you
are unable to compile the code in ssdSource, please update to the latest version of
your compiler and retry before reporting the bug to [email protected].

Additionally, the Cray and Intel compilers and the GNU 5.0 compiler fully support the 
Fortran 2008 parallel programming features needed to build the coarray example in 
Chapter 12.  Producing parallel executables with GNU Fortran requires building and
linking to an OpenCoarrays (http://opencoarrays.org) transport layer.