Using PHENIX Muon Software

• Works with pro.18.
• Switch to compiled response step ! See the presp_muon.C. For now, the compiled response is not able to generate the mupar.root file and I store a good mupar.root file in the data area.
• Work now with 3D field map ! Map is $TUTORIAL/data/Sim3D01.root, modifications to $TUTORIAL/data/pisa.kumac, $TUTORIAL/resp/macros/presp_muon.C and $TUTORIAL/preco/macros/preco_muon.C and preco_eval.C.
• Add HIJING generator, and change the directory tree in order to use the same places/scripts for any input file.

This tutorial aims to help beginners to run through the whole dimuon analysis chain from event generation to invariant mass plot, using the PHENIX software.

It was first written by Yajun Mao and is now maintained by Rapha? Granier . Comments or criticisms are very welcome !

Note : if you get lost with some acronyms we use, have a look two these nice pages : Bill's acronyms or David's abbreviations, both containing interesting links.

Five steps

• Event generation : build particle 4-momenta with a proper generator. Two generators are proposed in the tutorial :
  • PYTHIA to generate J/Psi -> mu mu events
  • HIJING to generate common Gold Gold collisions
• Hits generation : build the proper hit points coordinate in PHENIX detector. The PISA (PHENIX Integrated Simulation Application) program takes care of this.
• Detector response : simulate the response of PHENIX detectors. The output of this step is a PRDF file (Phenix Raw Data Format, identical to real data).
• Reconstruction : Read the prdf and reconstruct the events. The output is a DST file.
• Analysis : read back the dst, make plots,...

Lesson 1 : Running blind

First of all, you need a RCF account, and to be familiar with the RCF environment.

Just create a directory to run the tutorial, for instance in your workarea. For this you :
> cd /phenix/workarea/[yourname]
> mkdir work
> cd work

Set the TUTORIAL variable to the area where it is located :
> setenv TUTORIAL /afs/rhic/phenix/users/raphael/tutorial

As the tutorial is on an AFS area, you should first be sure that you can see it. If the result of a
> ls $TUTORIAL
is a permission denied, then type :
> klog
and enter your AFS password. (AFS Tutorial)

Then, you have to launch various scripts to go through the five steps. Each script tells you what are its output files, and uses as input the result of the main previous output.

Note : if you don't want to generate 1000 events for a first try, you can give a smaller number, as the first argument of each script.

• To generate 1000 J/psi events (< 1 hour),
  > $TUTORIAL/event_gen/gen_pythia
  Main output : jpsi_pyt.dat (~ 2 MBytes)

• To run pisa (~ 3 hours),
  > $TUTORIAL/simu/simulate
  Main output : jpsi_pis.root (~ 20 MBytes)

• To run response chain (~ 2 hours),
  > $TUTORIAL/resp/respond
  Main output : jpsi_res.prdf (~ 50 MBytes)

• To run reconstruction chain (< 1 hour),
  > $TUTORIAL/preco/reconstruct
  Main output : jpsi_rec.dst (~ 10 MBytes)

• If you want to see the mass spectrum you just generated, launch ROOT and execute the plmass.C macro.
  > root
  root [0] .x plmass.C
  You will see something like this :
  
  
  To quit root :
  root [1] .q

• To do Post-DST analysis (~ 1 minute), ! this is not the official framework, which is being included in the tutorial soon !
  > $TUTORIAL/dstana/analyse
  Main output : jpsi_dst.root (~ 40 kBytes)

Note : this post-dst analysis is unofficial, but still usefull. Run the plot_mass.C macro under root, you will get a mass plot from the DST's.

Lesson 1' : Same exercise with HIJING

If you want to make the same exercice with Gold-Gold events @ 200 GeV, generated by HIJING, you can use the five steps :
> $TUTORIAL/event_gen/gen_hijing 20 gold200
> $TUTORIAL/simu/simulate 20 gold200
> $TUTORIAL/resp/respond 20 gold200
> $TUTORIAL/preco/reconstruct 20 gold200
> $TUTORIAL/dstana/analyse 20 gold200

This will generate 20 events. The output of the various steps are the same of the jpsi lesson, with 'gold200' instead of 'jpsi'.

Lesson 1.5 : Looking at histograms, ntuples

Before you learn more about what you just did, it might be interesting to have a look to many control histograms and ntuples that were created during the reconstruction step.

The tool we use to do such things is root (you launched it at the end of lesson 1). First of all, you need to know the basics of it. If you don't, spend some time on the following pages :

• Root Home Page at CERN
• Root Educational Ressources at FERMILAB

Then open the mut.root file and explore the numerous histograms there. Here are the lists of histos and ntuples you will find, with some comments to help you a little :

• Some MuTr Ntuples
• Histograms

Note that some of them are not filled the way we launched the software.

Lesson 2 : Using official libraries

Each script you summoned in the first lesson was calling the local_setup.csh script which itself sources the /opt/phenix/bin/phenix_setup.csh script with the argument 'pro.17'. This script sets up environment variables in order to use a given set of PHENIX libraries.

The main thing is $LD_LIBRARY_PATH, that is the path where you will grab all your libraries. It is echoed in each script in order for you to know which version of the code you're using. You can check its value outside the script typing :
> echo $LD_LIBRARY_PATH
This tells you where your commands will try to grab PHENIX libraries, if you run outside the scripts. If you get nothing here (or wish to change the version you use) edit your .login and add :
source /opt/phenix/bin/phenix_setup.csh [pro or new]

To see all the libraries available, look into :
> ls /afs/rhic/phenix/PHENIX_LIB/sys/i386_redhat61

• pro versions are stable versions of our code.
• A new version is build everynight with the latest developpment.
• Other versions deserves specific purposes.

To know the status of the latest rebuilds, check the tinderbox.

To know the status of all the rebuilds, look at Laurent's nice page.

If you want to give a try to another set of libraries, you need to change the setup. Copy the local_setup.csh to your working area (the script will take this one instead of the one sitting in the TUTORIAL area) :
> cp $TUTORIAL/local_setup.csh .
Edit and modify it to point to another library, for instance the latest successfull 'new' rebuild:
source /opt/phenix/bin/phenix_setup.csh new

Run as in the first lesson. There is no guarantee that this will succeed, as we can't guess the status of the libraries your pointing to...

Usefull trick : you can tell root to explicitly show you were it grabs its libraries by putting the Root.ShowPath to true in the your .rootrc file.

Lesson 3 : Digging into the code

In your work area, create three directories to receive your source files, to build the software and to shelter the compiled libraries :
> mkdir Sources
> mkdir Builds
> mkdir Libraries
Note: foreigners might prefer to work in their AFS area, in order to edit the code with a locally running editor.

Go to your source directory :
> cd Sources

All Phenix code is stored and shared under CVS (Concurrent Versions System). If you don't know this utility yet, you might be interested by these two links : the CVS home page and PHENIX CVS web. The phenix_setup script settled the $CVSROOT variable for you to : /afs/rhic/phenix/PHENIX_CVS, the so-called repository.

Check-out the mut package (for instance) and have a look to the created directory :
> cvs co offline/packages/mut
> ls offline/packages/mut

See the numerous files you have now ? They correspond to the latest version of the mut software. To compile the mut library, first create a 'mut' subdirectory in your build area and generate the 'mut' Makefile:
> cd ../Builds
> mkdir mut
> cd mut
> ../../Sources/offline/packages/mut/autogen.sh --prefix=/phenix/workarea/[yourname]/Libraries
The argument after the prefix option is the place where the library and include files will be stored.

Then you can compile in two steps :
> make
> make install
The first build the libraries in a local .libs directory, the second one installs the library in your Libraries directory. (you can skip the first step if you're sure you want to install the libraries in the target area).

You now have to add this directory to your library path. Edit the local_setup.csh and add this line after the phenix_setup.csh call :
> setenv LD_LIBRARY_PATH /phenix/workarea/[yourname]/Libraries/lib:$LD_LIBRARY_PATH

Now, if you re-run the response or the reconstruction chain, you will use your own mut library. You are ready to work on PHENIX software.