Introduction

General information

A relational database has been developed based on the original (n,n'γ) work carried out by A.M. Demidov et al., at the Nuclear Research Institute in Baghdad, Iraq [1]. For reference, the complete ATLAS is provided as a pdf accompanying this software. A summary article [A.M. Hurst, L.A. Bernstein, and K. Song, arXiv:2001.11140v2 [physics.app-ph]] providing an overview of the project may be downloaded from here.

The information from the ATLAS includes:

γ-ray energies and intensities.
Nuclide and level information from which the γ-ray originated.
Target (sample) experimental measurement information.

All of this is described in greater detail in the schema.

Taken together, this information allows for the extraction of the flux-weighted (n,n'γ) cross sections for a given transition relative to a defined value. In the examples presented here, we are currently using the fast-neutron flux-weighted partial cross section for the production of the 847-keV 2⁺₁ → 0⁺_gs transition in ⁵⁶Fe, σ_γ=329.46 mb. This value can be changed to accommodate the user preference - see here for how to do this.

The (n,n'γ) data has been compiled into a series of ASCII comma separated value tables (the delimiter is a <TAB> in this case) in the CSV_DATA directory. The corresponding SQLite database is then created by executing the make && make run command and installed into the notebook_analysis and sql_codes directories after invoking the make install command. The installation procedure is described in detail elsewhere.

The database can then be interacted with directly via the SQLite engine. We have provided a suite of Structured Query Language (SQL) scripts in the sql_codes directory illustrating various methods for querying the data. The database can also be accessed via the Jupyter Notebook Python-browser interface. All of this is shown schematically below.

Getting started

The software provided with this package is intended to create a SQLite database on Linux and Mac OS X platforms. For Windows users, MinGW and Cygwin may provide a suitable alternative application environment/emulator (not tested). However, Windows-based environments have not been considered in the current project.

System requirements:

The SQLite3 database engine
The GNU C compiler gcc
To use the Jupyter Notebook to interact with the data, the programming language Python 2.7 or Python 3 is required.
In addition, several Python libraries are also required: numpy; scipy; matplotlib; pandas; ipython; jupyter; sqlite3; and, seaborn. For installation of Python and the basic package requirements see below.

Anaconda: An easy-to-use Python distribution and package manager. Once installed it allows for creation of several Python environments to seamlessly coexist. A big advantage being if you already have Python 2, you can easily create a Python 3 environment that won't interfere with anything else in your path; no system changes or even manual changes to your .bashrc or .cshrc login scripts are required. New Python libraries are then easy to search and install using conda methods, e.g., to search for and install the Python library Seaborn:
```
	      conda search seaborn
	      conda install seaborn
```
Also, Anaconda conveniently installs the Jupyter Notebook! To see a list of Python packages in your current environment simply type:
```
	      conda list
```
MacPorts (for Mac OS X): Enables easy compilation and installation of software packages, e.g., to install SQLite3:
```
	    sudo port install sqlite3
```
This is analogous to the apt-get install (Ubuntu/Debian) and yum install (Fedora) commands in Linux. A recipe for installing MacPorts and the most basic Python packages may also be found here.
pip: Another package manager enabling easy installation and management of software packages written in Python. To install pip:
```
	    sudo easy_install pip
```
Then to install a package:
```
	    pip install seaborn
```

Python installation

This section is only intended for those who may need to install Python from the source or are missing some of the basic libraries required to use the Jupyter Notebook supplied with this package. The following procedures should only be considered as a set of guidelines rather than a strict set of rules and deviations may be necessary. But hopefully it provides a useful starting point, if needed.

Linux

To install Python, first download the latest version from http://www.python.org and compile from the source. For example, Python-2.7.13:
```
	  tar -xvzf Python-2.7.13.tgz
	  ./configure
	  make
	  make install
```
Define the PYTHONPATH and LD_LIBRARY_PATH variables in your login script.

For the bash family, i.e. in your .bashrc script define:

	  export PYTHONPATH=$HOME/python
	  export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

Alternatively, for the csh family, in your .cshrc script define:

	  setenv PYTHONPATH=$HOME/python
	  setenv LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

Additional packages, mainly from the SciPy stack, also need to be installed. For Ubuntu/Debian flavors:

	  sudo apt-get update #If it's been a while!
	  sudo apt-get upgrade #sudo apt-get dist-upgrade
	  sudo apt-get install python-numpy python-scipy python-matplotlib python-pandas ipython python-seaborn

Finally, to install the Jupyter Notebook:

	  pip install jupyter #Python 2
	  pip3 install jupyter #Python 3

To install pip, see above.

Mac OS X

First make sure a recent version of Xcode is installed with command line tools and X11.
Install MacPorts according to OS version then run the following commands from the terminal:
```
	sudo xcode-select --install
	sudo xcode-build -license
	sudo port -v selfupdate
```
Check definition of PATH variable in .bashrc_profile or .profile in $HOME directory is set accordingly:
```
	  export PATH=/opt/local/bin:/opt/local/sbin:$PATH
```

Install ports related to installed python version, e.g., for Python-2.7:

	  sudo port install python27
	  sudo port install py27-numpy py27-scipy py27-matplotlib py27-pandas py27-ipython py27-seaborn

Set python27 and ipython27 to the default versions:

	  sudo port select --set python python27
	  sudo port select --set ipython py27-ipython

Install the Jupyter Notebook:
```
	  sudo port install py27-jupyter
```

Running Jupyter

To start the notebook server, execute one of the following commands from the terminal:

	jupyter notebook # or...
	ipython notebook

The terminal will then display some information about the notebook server including the URL of the web application (default: http://localhost:8888/tree). All being well, the notebook should then open in your browser. To execute a cell in a Jupyter Notebook press <SHIFT> + <ENTER> or <CTRL> + <ENTER>. More information on this utility and the notebook provided with this package may be found here.