pyInterface: support loading/saving of fileManager to hard drive

create functions to save/load a fileManager object to/from the hard drive.
These functions are located in pyInterface/package/_fileManager.py and are
executed by calling pyRootPwa.core.saveFileManager (or load). Create a new
script that creates a fileManager and saves it to the hard drive for later use.
The metadata eventsType enum has to be internally handled by a python class
that resembles an enum to allow pickle to save it to the hard drive (bug in
boost::python).
Change the fileManager so that it takes a config object to initialize instead
of a config filename (config object is initialized in the outer scripts).
Remove the initialization of the particleDataTable (should also happen in outer
scripts). Do not calculate the amplitude file names with a function call each
time you need them, but calculate them once upon initialization and save them
to a list.
pyInterface: add userInterface/calcAmplitudes.py script

add a high level script that takes a config file and calculates all amplitude
files that the fileManager (which should be created by using the
createFileManager) knows.
Remove initialization of particleDataTable in package/amplitude.py, this should
only happen in the outer level scripts.
decayAmplitude: move calcIntegrals.cc and testIntegral.cc

move calcIntegrals.cc and testIntegral.cc to legacyScripts since the integral
calculation is now done by the python script
pyInterface/userInterface/calcIntegrals.py.
pyInterface: add calcIntegrals python script

add userInterface/calcIntegrals.py script. This script calculates an amplitude
integral matrix from all the amplitude files determined by the file manager.
Before executing calcIntegrals.py you need to first run calcAmplitudes.py with
the same fileManager.
For this change we had to introduce a new package function "calcIntegrals"
which takes a list of amplitude files as argument and returns the
ampIntegralMatrix object. The package function extracts all the amplitude trees
from the amplitude root files and adds the waveNames from the amplitude
metadata to the ampIntegralMatrix object (this is the new method 'addWave').
Then calcIntegrals calls the ampIntegralMatrix.integrate method, which has been
rewritten to take a vector of TTrees as argument (the tree extraction was
previously done in the ampIntegralMatrix object).
pyInterface: add script to compare amplitude files

add script that compares amplitude files for differences.
storageFormats: fix enumeration syntax for older compilers

Fix the enumeration syntax in convertEventFile.cc and eventMetadata.cc since
RootPwa didn't compile on older compilers.
amplitudeBenchmark not ready
General: Improve README.md

add short tutorial on how to use the new python user interface to README.md.
Improve layout of README.md in general.
pyInterface: clean up config file

general clean up of the config file and the package/_config.py module.
Delete config entries "massBinDirectoryNamePattern" and
"dataAmplitudeDirectoryName". Delete amplitude category and put folders for key
and amplitude files into general section. Create category "other" and put all
weight related stuff, as well as amplitude subdirectory names in there.
Create a function that manages all the directory handling. The function checks
if the config file has the option and assigns a default if the option does not
exist. It also expands environment variables and checks if an absolute path was
given. If it recognizes a relative path it returns the path relative to the
position of the config file (and NOT relative to the current path).
Thanks to sensible defaults the config file works in theory without giving any
of the general options. The initialize method creates directories (for data, key
and amplitude files) if they do not exist yet.
pyInterface: add amplitudeBenchmark.py

add a script that runs a benchmark test if the result of the calcAmplitudes
script is consistent with the result of the script on a benchmark machine. Also
add a script that compares 2 amplitude files. The script will save 2 histograms
for the differences between the files, one for the real and one for the
imaginary parts.
pyInterface: add integralBenchmark.py

add a script that runs a benchmark test if the result of calcIntegrals script
is consistent with the result of the script on a benchmark machine. This
test ensures the precision of calcIntegrals on different machines.