Method 1 (Easiest) - RAT Container

The easiest way to both build and run RAT locally is now through the docker container. Full documentation, instructions, and explanation of what a container is are available at the Github repository. From the repo:

Singularity and Docker recipes to build a SNO+ environment for RAT.
For regular usage, simply download the pre-built container with the following instructions for your container platform of choice.

FEATURES

Full RAT-compatible environment, including ROOT5, GEANT4 and scons
Can build any version of RAT
GUI output support on all operating systems
TensorFlow and CppFlow (CPU-only for the time being)
Singularity and Docker compatibility
Cluster-compatible

Method 2 (Advanced) - Manual Installation of Dependencies

The traditional way to install RAT is to build the dependenices and RAT individually.

FFTW
- If you have admin access, install the packages (Debian/Ubuntu: fftw3, libfftw3-dev; RHEL/CentOS/SL/Fedora: fftw, fftw-devel)
- If not, download from http://www.fftw.org/download.html and build with the --with-pic option enabled when configuring; you will then need to point ROOT to the location of the FFTW libraries with the --with-fftw3-incdir and --with-fftw-libdir options when configuring.
GSL
- If you have admin access, install the packages (Debian/Ubuntu: libgsl0-dev; RHEL/CentOS/SL/Fedora: gsl, gsl-devel)
- If not, download from https://www.gnu.org/software/gsl/ and build with the --with-pic option enabled when configuring; you will then need to point ROOT to the location of the GSL libraries with the --with-gsl-incdir and --with-gsl-libdir options when configuring.
ROOT
1. Get the ROOT source tarball: https://root.cern.ch/download/root_v5.34.38.source.tar.gz
2. Untar somewhere, rename the directory if you like, then build it (adding extra library location options if FFTW and GSL are not installed to default locations):
```
    $ tar zxvf root_v5.34.38.source.tar.gz
    $ cd root
    $ ./configure --enable-minuit2 --enable-python --enable-mathmore
    $ make # Use -jN for N parallel job
        
```
3. Source the ROOT environment: source /PATH/TO/ROOT/bin/thisroot.sh
GEANT4
1. Get the source: http://geant4.cern.ch/support/source/geant4.10.00.p02.tar.gz
2. Untar, create a CMake build directory, and build:
```
    $ tar zxvf geant4.10.00.p02.tar.gz
    $ mkdir geant4.10.00.p02-build
    $ cd geant4.10.00.p02-build
    $ cmake -DGEANT4_INSTALL_DATA=ON -DCMAKE_INSTALL_PREFIX=/PATH/TO/geant4.10.00.p02 /PATH/TO/geant4.10.00.p02
    $ make
    $ make install
        
```
3. Source the environment: $ source /PATH/TO/geant4.10.00.p02/bin/geant4.sh
4. Source the development script: $source /PATH/TO/geant4.10.00.p02/share/Geant4-10.0.2/geant4make/geant4make.sh
cURL
- If you have admin access, install the packages (Debian/Ubuntu: curl, libcurl3; RHEL/CentOS/SL/Fedora: curl, curl-devel)
- If not, download from https://curl.haxx.se/download.html and build, and change RAT's config/EXTERNAL.scons to point to the correct location.
bzip2
- If you have admin access, install the packages (Debian/Ubuntu: bzip2, libbz2-1.0; RHEL/CentOS/SL/Fedora: bzip2, bzip2-devel)
- If not, download from https://sourceware.org/bzip2/index.html and build, and change RAT's config/EXTERNAL.scons to point to the correct location.
scons
1. Download scons from https://sourceforge.net/projects/scons/files/scons/3.1.2/scons-3.1.2.tar.gz
2. Extract scons and set the RAT_SCONS environment by:
```
    $ tar zxvf scons-3.1.2.tar.gz
    $ export RAT_SCONS = PATH/TO/scons-3.1.2
        
```

RAT

Clone the repository and configure:

    $ git clone git@github.com:snoplus/rat
    $ cd rat
    $ ./configure
    $ source env.sh

Build: scons

Along the way we set a lot of environment variables, which must always be set to run RAT. To make this easier, create a script to do it:

      # rat_env.sh

      source /PATH/TO/root/bin/thisroot.sh
      source /PATH/TO/geant4.10.00.p02/bin/geant4.sh
      source /PATH/TO/RAT/env.sh

Then, you can just `source rat_env.sh` and RAT is ready to go.

Manual updating

Rat is git managed code; therefore, you must fetch and merge the code to update it manually before doing scons, i.e.

      $ git fetch
      $ git merge
      $ scons

Scons build options

There a few options that can be passed to scons to disable or enable dependencies which are

scons profile=1, default 0, to turn on the profiling CFLAGS
scons debug=1, default 0, to turn on the debug CFLAGS
scons opt=0, default 1, to turn off the optimisation CFLAGS
scons zmq=0, default 1, to turn off the zmq dependence (packed dispatcher requires zmq).
scons xercesc=0, default 0, to turn off the xerces-c dependence (viewer GDML visualisation requires xerces-c).
scons g4vis=0, default 1, to turn off all visualisation.
scons verbose=1 or 2, default 0, to enable more RAT verbosity.
scons sconsverbose=1, default 0, to print full build commands.
scons define=DEF1,...,DEFN to set user defines to activate specific code sections useful for active development.

Installation against ROOT6 (Advanced Installation)

It is possible to install RAT against ROOT6, although the default for SNO+ software remains ROOT 5.34.38.

The installation follows closely the Manual Installation above except that both ROOT6 and GEANT must be installed against GCC 4.8.5 for RAT 6.18.1 or older. Newer versions of GCC are not compatible with the construction of RAT ROOT. For versions of RAT greater than or equal to 6.18.2, this restriction on the compiler version no longer applies.

ROOT
- To install ROOT versions after 6.06/08, a newer version of cmake is required (at least cmake 3.14.3).
- For RAT to compile (with versions older than 6.18.2), you must use GCC 4.8.5 as newer versions are not compatible.
- Installation:
  1. Get the ROOT source tarball: https://root.cern/download/root_v6.20.04.source.tar.gz
  2. Untar the source somewhere and create a build directory (adding extra library location options if FFTW and GSL are not installed to default locations):
```
$ tar zxvf root_v6.20.04.source.tar.gz
$ mkdir root-build
$ cd root-build
$ cmake -Dminuit2:BOOL=ON -Dpython:BOOL=ON -Dmathmore:BOOL=ON -Droofit:BOOL=ON \
$       -Dfortran:BOOL=OFF -Dfftw3:BOOL=ON -Dgsl_shared:BOOL=ON -Dgdml:BOOL=ON /PATH/TO/root_v6.20.04
$ make # Use -jN for N parallel job
		
```
  3. Source the ROOT environment: source /PATH/TO/ROOT/bin/thisroot.sh
- If you installed FFTW in a non-standard location, you may need to add a few options:
  - -DFFTW_INCLUDE_DIR=/PATH/TO/fftw/include
  - -DFFTW_LIBRARY=/PATH/TO/fftw/lib/libfftw3.a
- If you installed GSL in a non-standard location, you may need to add an option:
  - -DGSL_DIR:PATH=/PATH/TO/gsl
- NB: Newer versions of ROOT are required to be made via cmake instead of ./configure.
GEANT
- Same as the manual installation instructions above, but ensure you are building with GCC 4.8.5 (if using RAT versions older than 6.18.2).
All other dependencies and RAT:
- Same as the manual installation instructions above.
- If using non standard locations for packages, you may need to add them to your paths (example for GSL):
  - export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/PATH/TO/gsl/lib
  - export PATH=$PATH:/PATH/TO/gsl/bin

Method 3 (No longer supported but may still work for some) - Snoing

The SNO+ RAT code, tools and documentation can all be installed via the snoing tool. This tool aims to make the installation as simple and painless as possible. To start, however, you need a github account, as this is where all the snoplus code lives. To do so go to github to apply for an account, then ask for access to the snoplus organisation as explained in SNO+-doc-1462.

An ssh key for github is required to download all the snoing -dev packages. Follow the instructions at Github: Generating SSH Keys.

Once you have access to github you can download snoing via this command (make sure you have git installed):

      git clone git@github.com:snoplus/snoing.git

Now you can run snoing to install the snoplus code. To do so, navigate to the snoing directory and type:

      $ source env.sh

and then

      $ ./snoing.py rat-dev

If you are missing any libraries on your system, then snoing will tell you. You will have to install these manually. If snoing completes without errors, then you are done. To run rat simply type

      $ source install/env_rat-dev.sh
      $ rat

Updating the software

Snoing takes care of software updating via the '-p' command e.g.

      $ ./snoing.py -p rat-dev

updates rat-dev.

Troubleshooting

If snoing fails, then it will output "Snoing has failed, please consult the above error messages or the snoing.log file.". Above this line, snoing should output text explaining why it failed and will often give advice on how to solve the error. If this information is not sufficient to solve the problem, then email the snoing.log file to the MC group leader.

Known problems

On Ubuntu 12 geant4 will not be able to locate the openGL library when installing in graphical mode, you must do so for it. When you have found the location re-run snoing with the verbose -v option and enter the location when prompted.
ROOT 5 will not compile with GCC 9 (see this forum post).
ROOT versions < 5.34.38 will not compile on CentOS 8 (and more generally, with newer compilers).
ROOT versions < 5.34 will not install on Mac OS 10.8.
XQuartz must be installed on Mac OS 10.8+.
ROOT versions > 5.32 requires XCode 4.3+ and the command line tools on Mac OS 10.7. If you have XCode 4.1/4.2 you will need to get a fresh install from the App Store, the command line tools can then be installed from the XCode→Preferences→Downloads menu.

Snoing options

Snoing has the following options:

  Usage: snoing.py [options] [package]

  Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -c CACHE_PATH         Cache path.
  -i INSTALL_PATH       Install path.
  -v                    Verbose Install?
  -l, --list            List packages, without installing anything.
  -a                    All packages?
  -k, --clean           Clean temporary files.

  Optional Install modes:
    -g, --graphical     Graphical install?
    -x                  Grid install (NO X11)?

  Optional Actions:
    Default snoing action is to install the specified package, which
    defaults to rat-dev.

    -q                  Query Package Status?
    -r                  Remove the package?
    -d                  Install dependencies only?
    -p                  Progress/update the package?

  Github authentication Options:
    Supply a username or a github token, not both.

    -u USERNAME         Github username
    -t TOKEN            Github token

Home