Clarify debug message.
Simplify beginners guide.
Add message if MPI support is compiled into software.
Fix fitting of gain calibration histos.

Fix the number of entries required for fits of ADC distributions during
gain calibration, a bug that was introduced when the separate fit
programs for alignment and gain were replaced by mpi_fit.
Bump version numbers.
FileManager should not assert when it encounters an empty file w/o a run header (eg. 0 byte files), but gracefully continue.
This should let acroot_check continue proceedding its list of files to be checked, instead of aborting after the first 0 byte file.
This way we don't need more than one iteration to detect all broken files.
Add preliminary support for ICC + Intel MPI.

Using these settings a ICC + Intel MPI build can be executed at HPC cluster:
module switch intel gcc/4.3 &>/dev/null
module unload intel &>/dev/null
module load intel/12.1 &>/dev/null
module switch openmpi intelmpi &> /dev/null

This aims at testing the "auto-vectorization" feature of ICC. When passing "-parallel" to ICC, it tries to
automatically OpenMP-parallize loops if possible, without having to change the source code at all.

We can test OpenMP + MPI hybrid jobs, for jobs spending considerable more amount in computations than I/O:
eg. in JARA queue we have access to 12 core machines, which could be used like this:

core  1 - reader 1
core  2 - reader 2
core  3 - reader 3

core  4 - consumer 1 (fed by reader 1), thread 1 (i/o receive + computation)
core  5 - auxilary thread 2 - to speed-up computing of the single chunk received by consumer 1
core  6 - auxilary thread 3 - to speed-up computing of the single chunk received by consumer 1

core  7 - consumer 2 (fed by reader 2), thread 1 (i/o receive + computation)
core  8 - auxilary thread 2 - to speed-up computing of the single chunk received by consumer 2
core  9 - auxilary thread 3 - to speed-up computing of the single chunk received by consumer 2

core 10 - consumer 3 (fed by reader 3), thread 1 (i/o receive + computation)
core 11 - auxilary thread 2 - to speed-up computing of the single chunk received by consumer 3
core 12 - auxilary thread 3 - to speed-up computing of the single chunk received by consumer 3

Job Settings:
- 12 cores per node
- 3 readers per node
- 1 consumer per reader (but with 2 additional computation threads)
-> readers per node + readers per node * (consumers + extraThreads) = 3 + 3 * (1 + 2) = 12

Here's an example workflow for looping over 1000 ACQt files with 1 hybrid job spanning 100 nodes (100 * 12 = 1200 cores).
- Node 1 reads file 1 using reader 1, file 2 using reader 2, and file 3 using reader 3 simultaneously.
  - Once chunk 1 of file 1 is read, consumer 1 will receive it.
    - Thread 1, which just received the data launches the auxiliary threads then locks event 0, analyzes it, while thread 2 locks event 1, analyzes it, etc..
    - This runs in parallel until all events are analyzed. This kind of load-balancing will make sure
      that no threads ever sleeps. We can't assume that each event takes the same time to process and
      thus can only benefit if we use all threads together during the whole processing time.
  - The same logic is executed for file 2, and file 3 in parallel, all on the same node.
- Node 1 repeats this logic until eg, file 1-10 were processed.

- Node 2 reads file 11 using reader 1, file 12 using reader 2, and file 13 using reader 3 simultaneously.
  - Same as above.
- Node 2 repeats this logic until eg, file 11-21 were processed.
...
Continued until Node = 100

Obviously debugging such jobs is very hard, so we need to ensure that MPI is working perfectly first, before
we can start toying around with another level of complexity: OpenMP shared-memory parallalization.

For the user the complexicity stays the same, you only need to think once about your job settings, and eventually tune them.
It's a matter of passing the right parameters to run_parallel_acqt_job.py when submitting jobs, but your program
probably needs no or few changes.

TODO:
- Enable parallelization (ICC compiler option)
- Actually request X additonal threads in each reader (omp_set_num_threads). The auto-vectorization then uses
  X threads to speed-up all outer loops, etc.
- Request hybrid jobs in jub submission script (run_parallel_acqt_job.py)
- If auto-vectorization is not enough, add specific OpenMP pragmas to FileManager, to divide the N events
  in the chunk across the X+1 threads, and analyze them in parallel.
Fix no-longer valid comments, and add concerns about the ACicc-compiler warnings hack.
MPI: Provide static accessors for OMPI_COMM_WORLD_SIZE and PMI_SIZE.

The function to access these environment variables is:

IO::MPIEnvironemnt::NumberOfProcesses()

which is a static function.

These environment variables can be useful if you don't have access to an
instance of the MPIEnvironment. Example: Generic MPI jobs which do not
use the FileManager.

The accessors functions are implemented in analogy with
IO::MPIEnvironment::RankOfCurrentProcess()
MPI: Decompress chunks in FileManager to avoid code duplication.

The decompressByteArray function was implemented in FileManager.C and
MPIEnvironment.C which lead to code duplication. In fact the two
functions already differed in the way they handled invalid chunks.

Also cleaned up the naming and handling of some of the size variables.
MPI: Moved start/stop of runtimer to the proper place.
Added timers to benchmark how effective MPI processes run.

At the end of your program run you will see a table which should give
you the following information:

For every process you will see how much time they spent in the event
loop (consumers) / transmission loop for ACQt files (readers). Two
numbers will be printed:

- the time spent processing: time spent doing actual work
- total time: total time in event loop (processing time + time spent
  waiting for other processes)
- efficiency of the process (processing time*100 / total time)

You should use these numbers to optimize your program such that you use
as few readers as possible under the condition that your consumers stay
close to 100% efficiency.

You will also get to see a number to check how long the process was idle
after it finished. This is the timer that a process has to wait until
all the other processes finished working through their respective lists
of ACQt files.
Fix tutorial.
Added MakeStandardCustomFileName to ObjectManager
Added 3 features to the Object Manager:

1) Added a static function to write an TObject to a root file by resultdir, prefix and suffix.
2) Added the function ClearHistograms() to reset all histograms of the ObjectManager.
3) If you read Objects from file also push back the clone to the object list. That enables you to 'update' files with the ObjectManager. Now you can read some Objects from file and add some new by the Function Add() and after that save your changes by WriteToFile().
Some cleanup in the ObjectManager class.

- Replaced QVector by std::vector
- Removed unnecessary conversion to QString
Cleanup of ClearHistograms() in ObjectManager

Renamed it to ResetHistograms(), corrected indention and style and simplified it a bit.
Cleanup and add documentation
Cleanup of ObjectManager::WriteObjectToRootfile

Added function to save a TObject in a desired file.
Merge branch 'ab_newFeaturesForObjectManager' into dev

Signed-off-by: Andreas Bachlechner <bachlechner@physik.rwth-aachen.de>