Renaming project to ProfugusMC instead of Profugus.

##---------------------------------------------------------------------------##

## Profugus/CMakeLists.txt

## ProfugusMC/CMakeLists.txt

##---------------------------------------------------------------------------##

## Copyright (C) 2011 Oak Ridge National Laboratory, UT-Battelle, LLC.

##---------------------------------------------------------------------------##

##---------------------------------------------------------------------------##

## Profugus/PackagesList.cmake

## ProfugusMC/PackagesList.cmake

## Thomas M. Evans

## Monday December 2 21:24:6 2013

##---------------------------------------------------------------------------##

## PLATFORM SUPPORT

##---------------------------------------------------------------------------##

TRIBITS_DISABLE_PACKAGE_ON_PLATFORMS(Profugus Windows)

TRIBITS_DISABLE_PACKAGE_ON_PLATFORMS(ProfugusMC Windows)

##---------------------------------------------------------------------------##

## end of PackagesList.cmake

##---------------------------------------------------------------------------##

## Profugus/ProjectName.cmake

## ProfugusMC/ProjectName.cmake

## Thomas M. Evans

## Tuesday August 7 16:1:14 2012

##---------------------------------------------------------------------------##

# Must set the project name as a varaible at very beginning before including

# anything else

SET(PROJECT_NAME Profugus)

SET(PROJECT_NAME ProfugusMC)

##---------------------------------------------------------------------------##

## end of Profugus/ProjectName.cmake

## end of ProfugusMC/ProjectName.cmake

##---------------------------------------------------------------------------##

Description

***********

Profugus is an open-source mini-application (mini-app) for radiation

transport and reactor applications.  It contains the fundamental

computational kernels used in the Exnihilo code suite from Oak Ridge

ProfugusMC is an open-source mini-app for Monte Carlo radiation

transport.  It contains a simplified multigroup neutron transport

solver similar to that used in the Exnihilo code suite from Oak Ridge

National Laboratory. However, Exnihilo is production code with a

substantial user base. Furthermore, Exnihilo is export controlled.

This makes collaboration with computer scientists and computer

engineers difficult.  Profugus is designed to bridge that gap.  By

This makes collaboration with computer scientists and hardware

vendors difficult.  ProfugusMC is designed to bridge that gap.  By

encapsulating the core numerical algorithms in an abbreviated code

base that is open-source, computer scientists can analyze the

algorithms and easily make code-architectural changes to test

performance without compromising the production code values of

Exnihilo.

Profugus is **not** meant to be production software with respect to

problem analysis.  The computational kernels in Profugus are designed

to analyze *performance*, not *correctness*.  Nonetheless, users of

Profugus can setup and run problems with enough *real-world* features

to be useful as proof-of-concept for actual production work.

Profugus is also used as a test-bed mini-app for the ASCR projects

XPRESS and MCREX.

Profugus Development Team

ProfugusMC is based off of the larger Profugus application

(available at https://github.com/ORNL-CEES/Profugus).  Profugus

is a larger code base including both deterministic and Monte

Carlo radiation transport components.  While Profugus is designed

to run a range of different problems, ProfugusMC is much smaller,

simpler, and runs a pre-determined transport problem (a version

of the C5G7-MOX benchmark problem).

The computational kernels in ProfugusMC are designed

to analyze *performance*, not *correctness*.

ProfugusMC Development Team

=========================

Profugus contains the computational kernels from the Exnihilo code

ProfugusMC contains the computational kernels from the Exnihilo code

base. The core Exnihilo development team consists of the following

scientists (listed alphabetically)

* Kevin Clarno <clarnokt@ornl.gov>

* Elliott Biondo <biondoed@ornl.gov>

* Greg Davidson <davidsongg@ornl.gov>

* Tara Pandya <pandyatm@ornl.gov>

* Stuart Slattery <slatterysr@ornl.gov>

* Katherine Royston <roystonke@ornl.gov>

* Rachel Slaybaugh <slaybaugh@berkeley.edu>

Profugus is developed and maintained by the following team:

* Tom Evans <evanstm@ornl.gov>

ProfugusMC is developed and maintained by the following team:

* Steven Hamilton <hamiltonsr@ornl.gov>

* Stuart Slattery <slatterysr@ornl.gov>

* Tom Evans <evanstm@ornl.gov>

Profugus Packages

ProfugusMC Packages

=================

Profugus constains the following code mini-apps:

ProfugusMC constains the following packages:

**MC**

   Mini-app of Monte Carlo computational kernel.

**Matprop**

   Data structures for storing material properties (cross-sections).

Profugus is designed to build and run with a minimum of dependencies.

However, there are some requirements.  The third-party software (TPLs)

necessary to build Profugus is all open-source and freely available.

The TPLs for Profugus are listed in the following table:

ProfugusMC is designed to build and run with a minimum of dependencies.

It uses the TriBITS build system and pieces of the Trilinos linear algebra

library.  The necessary components are built into ProfugusMC, and no additional

libraries/repositories are needed.

The TPLs for ProfugusMC are listed in the following table:

+-----------------------+---------------+---------------------------------------+

| TPL                   | Required      | Comments                              |

+=======================+===============+=======================================+

| TriBITS               | Yes           | TriBITS is the Trilinos build system  |

+-----------------------+---------------+---------------------------------------+

| Trilinos              | Yes           | Trilinos is an open-source solvers    |

+-----------------------+---------------+---------------------------------------+

| BLAS/LAPACK           | Yes           | Use vendor-specific implementation    |

+-----------------------+---------------+---------------------------------------+

| MPI                   | No            | OpenMPI and MPICH are suggested       |

+-----------------------+---------------+---------------------------------------+

| HDF5                  | No            | Parallel HDF5 will allow output of    |

| CUDA                  | No            | Necessary for GPU-enabled kernel      |

+-----------------------+---------------+---------------------------------------+

Building The Code

*****************

The most straightforward method for building Profugus is to use the

scripts in `Profugus/install`.  Profugus uses the `TriBITS` build

The most straightforward method for building ProfugusMC is to use the

scripts in `ProfugusMC/install`.  ProfugusMC uses the `TriBITS` build

system.  This system is a set of package-based extensions to standard

cmake.  The components of TriBITS and Trilinos that are required are

included in the Profugus distribution.

included in the ProfugusMC distribution.

The preferred mechanism for using the build scripts is to make a

*target* directory where the build is to be performed::

   > pwd

     /home/me

   > mkdir debug

     /home/me/debug/target

The `install` directory contains several example build scripts.

General options for all platforms (which can be overridden at

configure time) are specified in the `install/base.cmake`::

   ##---------------------------------------------------------------------------##

   ## CMAKE BASE FILE

   ##---------------------------------------------------------------------------##

   # Default build all packages

   SET(Profugus_ENABLE_MC      ON CACHE BOOL "")

   # Turn on tests

   SET(Profugus_ENABLE_TESTS ON CACHE BOOL "")

   SET(Profugus_TEST_CATEGORIES "BASIC" CACHE STRING "")

   # Turn on SS code and optional packages by default

   SET(Profugus_ENABLE_ALL_FORWARD_DEP_PACKAGES OFF CACHE BOOL "")

   SET(Profugus_ENABLE_ALL_OPTIONAL_PACKAGES    ON  CACHE BOOL "")

   SET(Profugus_ENABLE_SECONDARY_STABLE_CODE    ON  CACHE BOOL "")

   # Compiler options

   SET(BUILD_SHARED_LIBS ON CACHE BOOL "")

   SET(CMAKE_CXX_FLAGS "-std=c++11 -Wno-deprecated-declarations" CACHE STRING "")

   SET(Profugus_ENABLE_CXX11:BOOL=ON)

By default, all of the packages inside of Profugus are turned on.

Furthermore, *C++-11* is **required**.  The default options specify

*C++-11* is **required**.  The default options specify

the appropriate compiler flags for gcc.  The tests are also turned on

by default; to disable tests in any upstream package simply do not

explicitly *ENABLE* that package.  For example, to build the *MC*

package and all of its tests but only include required *source* from

upstream packages, the user would specify::

   SET(Profugus_ENABLE_MC ON CACHE BOOL "")

   SET(ProfugusMC_ENABLE_MC ON CACHE BOOL "")

In this case, only the pieces of *Utils* needed to build *MC* are

compiled. All tests can be turned off by setting

**Profugus_ENABLE_TESTS** to **OFF**.

**ProfugusMC_ENABLE_TESTS** to **OFF**.

The `install` directory contains several build scripts that are all

suffixed by the platform name.  The source and install locations

must be set. Also, to enable a optimized build set **BUILD** to

**RELEASE**.  Adjust the paths and libraries for LAPACK to fit your

platform.  The example assumes that the ATLAS LAPACK is available.

Any standard LAPACK distribution will work.

**RELEASE**.

To complete the configuration, execute this script inside the *target*

directory and then make/test/install::

   > pwd

     /home/me/debug/target

   > sh /home/me/Profugus/install/cmake_x86_64.sh

   > sh /home/me/ProfugusMC/install/cmake_x86_64.sh

   > make -j 8

   > ctest -j 8

   > make -j 8 install

In order to run Profugus, simply run *<INSTALL_DIR>/bin/profugus*.

The executable takes an optional argument *-arch <cpu/gpu>* to toggle

between architectures (assuming multiple architectures are enabled at

configure time).  You can also change the default number of particle

histories per cycle by adding the argument *-np N*, where *N* is

a positive integer.  ProfugusMC will solve a Monte Carlo criticality

problem and then compare the result against a known reference solution.

##---------------------------------------------------------------------------##

## Profugus/TPLsList.cmake

## ProfugusMC/TPLsList.cmake

## Thomas M. Evans

## Tuesday August 7 16:10:44 2012

##---------------------------------------------------------------------------##

#

#   Trilinos/cmake/TrilinosTPLs.cmake

#

SET(Profugus_TPLS_FINDMODS_CLASSIFICATIONS

SET(ProfugusMC_TPLS_FINDMODS_CLASSIFICATIONS

  HDF5   "cmake/TPLs/"   SS

  )