Install and run MEMPHYS software

and the associate toolkits

Table of Contents

What the user have to know?

The user is supposed to know how to practice more or less:

the Linux OS or the MacOSX (Ceci est un changement de JEC et de GB), (Nouveau changement
the CMT code management tool,
the SVN the code version repository management tool (this is an alternative to the more usual CVS tool),
the C++ language,
the Geant 4 simulation tool,
the OpenScientist toolkit especially have a look at the AIDA abstract interface for the tuple creation and, also some practice of the OpenScientist visualisation to run the MEMPHYS_session executable
the ROOT toolkit if one wants to make analysis/ploting using this package.

Installation of the Plug-ins and the MEMPHYS package

It is supposed that the SVN, CMT (at least version v1r18), ROOT (at least version 4) tools are available under the plateform used hereafter. For definitiveness it is explicitely shown the commands to be executed under the UNIX/csh shell. Usually the toolkits are also providing UNIX/sh shell command file. The Mac XXX will be documented later.

The OpenScientist toolkit

If the user is running under Linux SL3 with the compiler gcc- 3.2.3, the OpenScientist v16r0 toolkit binariies may directly downlaoded here. The CLHEP 2.0.3.1 and Geant 4 8.2 version are part of the toolkit and includes all the include files, the libraries and the binnaries necessary for the development of the MEMPHYS code or similar codes.

So, the user proceeds as followed (UNIX):

download the zip file
unzip on a kits area (see the Kits & CMT hierarchy) that may be different of his/her work area
cd OpenScientist/v16r0
chmod a+x install
./install

To use the toolkit in stand alone mode or to see if the installation was fine, first of all setup the environment by sourcing:
csh> source <path>/OpenScientist/v16r0/aida-setup.csh
( sh> . <path>/OpenScientist/v16r0/aida-setup.sh )
Then, for instance one may experience the ploting capability :

UNIX> aida-config
UNIX> onxlab

The user may see the famous gaussian distribution and the associate fit....

Also, the user may play with Geant4 interactively and show the event display. Have a look at the novice examples or a simpler example as followed:

UNIX> G4Simple_session
In the Geant 4 menu, starts with "Init" and then "Run", some tracks will appear when the number of events are validated
To show the geometry: follow the "Physical Volumes" in the "Tree actions" and clik on the different directories and leaves. One may see the following figure:

The MEMPHYS package

To install the MEMPHYS package, one may adopt a directory hierarchy as followed (UNIX):

define at the login phase the CMTPROJECTPATH environment variable:

setenv CMTPROJECTPATH "<common-area-path>/kits:<personal-area>"

create if not already done the <common-area-path>/kits area for the OpenScientist toolkit as described above, but also the ROOT toolkit, CMT tool ...
create the <common-area-path>/CMTI/ area:
- create a /cmt/project.cmt file with the simple ligne

project CMTI

to install the OpenScientist-CMT Interfaces for OpenScientist toolkit and the ROOT toolkit

download the Interfaces here (TBD)

edit the OpenScientist/v16r0/cmt/requirement file and change the OSC_home macro according to the local implementation as example

#macro OSC_home "/usr/local/OpenScientist/v16r0"
macro OSC_home "/home/campagne/kits/OpenScientist/v16r0/"

edit in the same spirit, edit the ROOT/<version>/cmt/requiement file to change the ROOT_native_version and the ROOT_home macros, as for instance

#macro ROOT_native_version "v5-13-04b"
macro ROOT_native_version "4.03.02"

macro ROOT_home "/home/campagne/kits/root-${ROOT_native_version}"

create a <personal-area>/OSArea area :
- create a /cmt/project.cmt file with the simple code making the bridge between the MEMPHYS-like package and the common kits used to develop and use them:

project OSArea

use OpenScientist v16r0
use CMTI

download the MEMPHYS package using
- either a tarball at the following link: TBD if possible
- either the SVN software:
  - define the environment variable:

setenv SVNURL "https://svn.lal.in2p3.fr/Opera/Glob"

Check Out the HEAD version of the MEMPHYS package if you want to be a developer (ie. make later some "svn commit" order):

svn co ${SVNURL}/MEMPHYS/HEAD MEMPHYS/<new-version>

Look at the repository SVNURL with your Web browser and see in the MEMPHYS/tags directory the latest tagged version to choose the new-version tag. In general new-version is composed with a <major> and a <minor> number (eg. v<major>r<minor>) and the usage is that <major> indicates non backward compatibility (notice that it might be that <minor> release are non backward compatible).

execute the CMT setup:

source <common-area-path>/kits/CMT/<version>/mgr/setup.csh

Then, one needs to reconfigure the MEMPHYS environment using the CMT ad hoc command

UNIX> cd MEMPHYS/<version>/cmt
UNIX> cmt config
UNIX> source setup.csh

At this stage one may wander if the environment is correct and if CMT will find all the packages to proceed to a successful compilation and linkage. One can use the following cross-checks:

UNIX> cd MEMPHYS/<version>/cmt>
UNIX> cmt show path
# Add path /home/campagne/projets/OSArea from initialization
# Add path /home/campagne/kits/OpenScientist/v16r0 from ProjectPath
# Add path /home/campagne/CMTI from ProjectPath
# Add path /home/campagne/CMTI from ProjectPath

Here it is shown that the CMTPROJECTPATH is well defined and that the different project.cmt files are correctly configurated. Then uses,

UNIX> cmt show uses
# use OpenScientist v16r0 Interfaces
# use ROOT v1r* Interfaces (native_version=4.03.02)
#
# Selection :
use CMT v1r18p20051108 (/home/campagne/kits)
use ROOT v1r51000p0 Interfaces (/home/campagne/CMTI/)
use OpenScientist v16r0 Interfaces (/home/campagne/CMTI/)

to see if the OpenScientist and ROOT Interface packages are found (this does not mean yet that the Interfaces are correctly tuned...)

If the above cross-checks are successfuly passed, then one can proceed to the compilation and the link:

UNIX> cd MEMPHYS/<verson>/cmt
UNIX> gmake

If the all the process of compilationand link is ok, then one should see the following lines:

[...]
------> MEMPHYS_session ok
------> (constituents.make) MEMPHYS_session done
all ok.

At the stage, one has build sucessfully MEMPHYS_session (the interactive version mostly for visualisation) and the MEMPHYS_batch (the batch version mostly for tuple production on large statistics).

Simple runs

Usually the user starts an UNIX session and want to run MEMPHYS. The two things to do are:

1) be sure to define the CMTPROJECTPATH variable (at login or by sourcing a meta-setup)
2) execute the MEMPHYS setup (no more necessary to run "cmt config"):
UNIX> cd <personal-area>/OSArea/MEMPHYS/<versioin>/cmt
UNIX> source setup.csh

The directory hierarchy of the MEMPHYS package is the following:

source	source Core directory
application	source files where the main steering routine is defined
MEMPHYS	include files of the Core
cmt	directory where the CMT management files are located (requirements, setup/cleanup)
data	event file directory. NUANCE style is used to code the primary vertex particles
run	executable are run from this directory, the inputEventfile symbolic link to an existing event file should be set before run. There are also a collection of ROOT macros to decode the output event sturcture stored into the tuple.
scripts	Geant4 and OpenScientist scripts

Interactive session

In an interactive session the tuple generation is desable and one starts as followed:

UNIX> cd $MEMPHYSROOT/run
UNIX> ../$CMTCONFIG/MEMPHYS_session.exe

After more or less 15'' the geometry is loaded, and 15'' more is needed to see the OnX screen session. Then in the Geant menu, one should validate the number of event to process via the Run sub-menu. The first event is processed and the track of the optical volume are dispayed. By clicking on the eye then it is possible to rotate the event, zoom and so on. One may see the following screen:

One can visualize the "Hits" using the MEMPHYS menu, although it is then useful to use the zoom by using CTRL-Shift + drag the mouse in the ("Hand mode" see right icons).

Using "Arrow Mode" (right icons) the user enter in picking mode to get some ascii information on the object (or collection of objects selected by CTRL-Shift + drag mouse).

Batch mode

In the batch mode, the user produces an event tuple (run/MEMPHYS.root) created via the AIDA abstract interfaces implementation by OpenScientist. The I/O is performed in ROOT-I/O repackaged format that can be analysed

either using compilated AIDA code (MEMPHYS_analysis_aida_ROOT.exe, MEMPHYS_analysis_ROOT.exe) generated by compiling as:

UNIX> you are in the run directory
UNIX> (cd ../cmt ; gmake ROOT)

The difference between the two applications are XXX

either using interactive OnX session ()

or using the ROOT toolkit using the MEMPHYS_xxx.C macros

The structure of the tuple for the moment is the following:

std::string column = "int eventId, inputEvtId, interMode, vtxVol, ";
column += "ITuple vtxPos = { double x, y, z }, ";
column += "int nPart, leptonIndex, protonIndex, ";
column += "ITuple track = { int pId, parent, float timeStart, ";
column +=                  "ITuple direction = { double dx, dy, dz }, ";
column +=                  "double mass, pTot, ETot, ";
column +=                  "ITuple momentum = { double px, py, pz }, ";
column +=                  "ITuple startPos = { double x, y, z }, ";
column +=                  "ITuple stopPos   = { double x, y, z }, ";
column +=                  "int startVol, stopVol ";
column +=                "}, ";
column += "int nHits, ITuple hit = { int tubeId, int totalPE, ITuple pe = { float time} }, ";
column += "int nDigits, double sumPE, ";
column += "ITuple digit = { int tubeId, double pe, time }";