AliPhysics  04715ba (04715ba)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PWGLF Forward analysis
Collaboration diagram for PWGLF Forward analysis:

Modules

 Scripts used in the analysis
 
 Algorithms
 
 Corrections
 
 Monte-carlo code
 
 Mid-rapidity tracklet code for dN/deta
 
 Tasks
 
 Topical
 

Files

file  AliAODForwardMult.h
 Per-event \( N_{ch}\) per \((\eta,\varphi)\) bin.
 
file  AliFMDEventPlaneFinder.h
 
file  AliForwardUtil.h
 Various utilities used in PWGLF/FORWARD.
 
file  AliLandauGaus.h
 Declaration and implementation of Landau-Gauss distributions.
 
file  AliLandauGausFitter.h
 Declaration and implementation of fitter of Landau-Gauss distributions to energy loss spectra.
 

Classes

class  AliForwardCreateResponseMatrices
 
class  AliForwardTriggerBiasCorrection
 
class  AliForwardUtil
 
struct  AliForwardUtil::Histos
 
struct  AliForwardUtil::RingHistos
 
class  AliLandauGaus
 
class  AliLandauGausFitter
 

Detailed Description

Code to do the multiplicity analysis in the forward psuedo-rapidity regions

The Mid-rapidity tracklet code for dN/deta

Module: Mid-rapidity tracklet code for dN/deta

Introduction

The code in this section defines methods to measure the charged-particle pseudorapidity density over \(|\eta|<2\) using SPD tracklets.

Overview

The code in this module constitutes tools for analysing SPD tracklet data for the charged-particle pseudorapidity density. It is based on Ruben's original code (see pwglf_fwd_spd_tracklet_1), but differs in some important aspects.

  • Ruben's original code is designed to do a single pass of real-data and simulated ESDs (AliTrackletTaskMulti). The information extracted from those passes is then combined to form the final charged-particle pseudorapidity density using an external script.
  • This code also requires a pass of real-data (AliTrackletAODTask) and simulated (AliTrackletAODMCTask) ESDs, but the output is not near-final histograms but an array of data structures (AliAODTracklet) stored on the output AOD. The data structure contains basic information on each tracklet

    • Polar angle \( \vartheta \)
    • Azimuthal angle \( \varphi\)
    • Polar opening angle \( \delta\vartheta\)
    • Azimuthal opening angle \( \delta\varphi\)
    • Quality (sum on square residuals) \( \Delta\)
    • A set of flags

    Tracklet structures from simulations contain in addition

    • First cluster primary parent transverse momentum
    • First cluster primary parent particle type
    • Second cluster primary parent transverse momentum
    • Second cluster primary parent particle type

    During the AOD production, no cuts, except those defined for the re-reconstruction are imposed. In this way, the AOD contains the minimum bias information on tracklets for all events,

    A second pass over the generated AODs is then needed - for both real (AliTrackletAODdNdeta) and simulated (AliTrackletAODMCdNdeta). In this pass, we can

    • Impose additional constrains on the events e.g., location of primary vertex, centrality, event class and so on.
    • Impose additional constrains on the tracklets

    And for AODs corresponding to simulated data, we can also

    • Reweigh tracklets according to the cluster primary parents transverse momentum and particle type.

    In this way, we do a single pass of ESDs for real and simulated data, and we can then process the generated AODs with various cuts imposed. The AODs are generally small enough that they can be processed locally and quickly (for example using ProofLite). This scheme allows for fast turn-around with the largest possible flexibility.

    The final charged-particle pseudorapidity density is produced by an external class (AliTrackletdNdeta2).

    Other differences to Ruben's code is that the output files are far more structured, allowing for fast browsing of the data and quality assurance.

Analysis flow

The analysis requires real data and simulated data, anchored to the real data runs being processed. For both real and simulated data, the analysis progresses through two steps:

  • A pass over ESD plus clusters to generate an AOD branch containing a TClonesArray of AliAODTracklet objects. In this pass, there are no selections imposed on the events. In this pass, the SPD clusters are reprocesed and the tracklets are re-reconstructed.

    In this pass, we also form so-called injection events. In these events, a real cluster is removed and a new cluster put in at some other location in the detector. The tracklets of the event is then reconstructed and stored. This procedure is repeated as many times as possible. The injection events are therefore superpositions of many events - each with a real cluster removed and replaced by a fake cluster. The injection events are used later for background estimates.

    When processing simulated data, the tracklets are also inspected for their origin. A tracklet can have three distinct classes of origins:

    • The tracklet is formed from two clusters generated by the same primary particle.
    • The tracklet is formed from two clusters generated by the same secondary particle.
    • The tracklet is formed from two clusters generated by two different particles (primary or secondary).

    The last class is the background from combinations of clusters that does not correspond to true particles. This background must be removed from the measurements.

    The second class, tracklets from secondaries, also form a background, but these tracklets are suppressed by cuts on the sum-of-square residuals

\[ \Delta = \left[\frac{\Delta_{\theta}^2\sin^2\theta}{\sigma_{\theta}^2}+ \frac{(\Delta_{\phi}-\delta_{\phi})^2}{\sigma_{\phi}^2}\right] \]

  • In the second pass, the tracklets are read from the AOD events and processed in \(\eta,\mathrm{IP}_z\) bins. The measured tracklets ( \(M\) or \(M'\)), tracklets from injection events ( \( I\) or \( I'\)) - and for simulated data - tracklets corresponding to primary ( \( P'\)), secondary ( \( S'\)), and combinatorial background ( \( C'\)), as well as the pseudo-tracklets corresponding to the generated charged, primary paricles ( \( G'\)), are histogrammed to form

\[ \frac{d^2N_X}{d\eta d\mathrm{IP}_z}\quad, \]

where \( X\) is \( M\) or \( I\) for real data, or \( M',I',P',S',C'\) or \( G'\) for simulated data.

For each of these tracklet samples, except \( G'\), we also form the 3-dimensional differential \(\Delta\) distributions

\[ \frac{d^3N_X}{d\eta d\mathrm{IP}_z d\Delta}\quad, \]

which are later used to estimate the background due to wrong combinations of clusters into tracks.

Once both the real and simulated data has passed these two steps, we combine the to data sets into the final measurement. The final measurement is given by

\[ R = \frac{G'}{(1-\beta')M'}(1-\beta)M, \]

where

\[ \beta' = \frac{C'}{M'}\quad\mathrm{and}\quad \beta = k\beta'\quad. \]

Here, \( k\) is some scaling derived from the 3-dimensional differential \(\Delta_M\) and \(\Delta_{M'}\) distributions .

Structure

There are classes for containing data, classes that represent analysis tasks, and classes that perform calculations, as well as specialized classes for analysis of simulation (MC) output.

Data structures

The classes AliAODTracklet and AliAODMCTracklet stores individual tracklet parameters. The difference between the two are that AliAODMCTracklet also stores the PDG code(s) and transverse momentum (momenta) of the mother primary particle (which may be the particle it self).

Tasks

The pass over the ESD is done by the classes AliTrackletAODTask and AliTrackletAODMCTask. These tasks generated the array of tracklets in the AOD events. The difference between the two is that AliTrackletAODMCTask inspects and groups each tracklet according to it's origin, and create pseudo-tracklets corresponding to the generated primary, charged particles.

The second pass is done by one of the three classes AliTrackletAODdNdeta, AliTrackletAODMCdNdeta, or AliTrackletAODWeightedMCdNdeta. These tasks build the ditributions

\[ \frac{d^2N_X}{d\eta d\mathrm{IP}_z}\quad, \]

and

\[ \frac{d^3N_X}{d\eta d\mathrm{IP}_z d\Delta}\quad. \]

The first task does this for \( X=M\) and \( I\), while the second and thhird tasks does this for \( X=M',I',P',S',C'\) and \( G'\). The third task reweighs all tracklets according to the particle specie(s) and transverse momentum (momenta) of the mother primary particle(s). AliTrackletWeights defines the interface used for reqeighing the data.

To use

AOD production

To produce the AODs with the tracklet information in, one needs to run a train with a task of the class AliTrackletAODTask (or AliTrackletAODMCTask for simulated data) and a task of the class AliSimpleHeaderTask in it. This is most easily done using the TrainSetup (Using the TrainSetup facility) derived class TrackletAODTrain.

For example for real data from run 245064 of LHC15o using the first physics pass

runTrain --name=LHC15o_245064_fp_AOD \
         --class=TrackletAODTrain.C \
         --url="alien:///alice/data/2015/LHC15o?run=245064&pattern=pass_lowint_firstphys/&ast;/AliESDs.root&aliphysics=last,regular#esdTree"

or for simulated data from the LHC15k1a1 production anchored to run 245064

runTrain --name=LHC15k1a1_245064_fp_AOD \
         --class=TrackletAODTrain.C \
         --url=alien:///alice/sim/2015/LHC15k1a1?run=245064&pattern=&ast;/AliESDs.root&aliphysics=last,regular&mc#esdTree

(note the addition of the option "&mc" to the URL argument)

In both cases a sub-directory - named of the name argument - of the current directory is created. In that sub-directory there are scripts for merging the output, downloading results, and downloading the generated AODs.

It is highly recommended to download the generated AODs to your local work station to allow fast second step analysis. To download the AODs, go to the generated sub-directory an run the DownloadAOD.C script. For example, for the real data analysis of run 245064 of LHC15o, one would do

(cd LHC15o_245064_fp_AOD && root -l -b -q DownloadAOD.C) 

and similar for the analysis of the simulated data.

Histogram production

To produce the histograms for the final charged-particle pseudorapidity density , one needs to run a train with a task of the class AliTrackletAODdNdeta (or AliTrackletAODMCdNdeta for simulated data) in it. This is most easily done using the TrainSetup derived class TrackletAODdNdeta.

For example for real data from run 245064 of LHC15o where we store the AODs generated above on the grid

runTrain --name=LHC15o_245064_fp_dNdeta \
         --class=TrackletAODdNdeta.C \
         --url="alien:///alice/cern.ch/user/a/auser/LHC15o_245064_fp_dNdeta/output?run=245064&pattern=* /AliAOD.root&aliphysics=last,regular#aodTree"

or for simulated data from the LHC15k1a1 production anchored to run 245064

runTrain --name=LHC15k1a1_245064_fp_dNdeta \
         --class=TrackletAODdNdeta.C \
         --url=alien:///alice/cern.ch/user/a/auser/LHC15k1a1_245064_fp_AOD/output?run=245064&pattern=* /AliAOD.root&aliphysics=last,regular&mc#esdTree

(note the addition of the option "&mc" to the URL argument)

If we had downloaded the AODs, we can use ProofLite to do this step

runTrain --name=LHC15o_245064_fp_dNdeta \
         --class=TrackletAODdNdeta.C \
         --url="lite:///${PWD}/LHC15o_245064_fp_dNdeta?pattern=AliAOD_*.root#aodTree"

and similar for simulated data

runTrain --name=LHC15k1a1_245064_fp_dNdeta \
         --class=TrackletAODdNdeta.C \
         --url="lite:///${PWD}/LHC15k1a1_245064_fp_dNdeta?pattern=AliAOD_*.root&mc#aodTree"

(note the addition of the option "&mc" to the URL argument)

Final result

The final result is obtained by runnin the class AliTrackletdNdeta2 over the histograms from both real data and simulations. As an example, suppose we ran or histogram production on the Grid and have downloaded the merged results into LHC15o_245064_fp_dNdeta/root_archive_000245064/AnalysisResult.root (using LHC15o_245064_fp_dNdeta/Download.C) and LHC15k1a1_245064_fp_dNdeta/root_archive_245064/AnalysisResult.root (using LHC15k1a1_245064_fp_dNdeta/Download.C). Then we should do

gROOT->LoadMacro("AliTrackletAODUtils.C+g");
gROOT->LoadMacro("AliTrackletdNdeta2.C+g");
p->Run(0x8,0x3FF,9,
"LHC15o_245064_fp_dNdeta/root_archive_000245064/AnalysisResult.root",
"LHC15k1a1_245064_fp_dNdeta/root_archive_245064/AnalysisResult.root",
"result.root");

(see AliTrackletdNdeta2::Run for more information on arguments)

Alternatively one can use the script Post.C to do this. The script is used like.

Post(simFile,realFile,outDir,process,visualize,nCentralities)

where

  • simFile is the simulation data input file (or directory)
  • realFile is the real data input file (or directory)
  • outDir is the output directory (created)
  • process are the processing options
  • visualize are the visualisation options
  • nCentralities is the maximum number of centrality bins

Processing options:

  • 0x0001 Do scaling by unity
  • 0x0002 Do scaling by full average
  • 0x0004 Do scaling by eta differential
  • 0x0008 Do scaling by fully differential
  • 0x0010 Correct for decay of strange to secondary
  • 0x1000 MC closure test

Visualization options:

  • 0x0001 Draw general information
  • 0x0002 Draw parameters
  • 0x0004 Draw weights
  • 0x0008 Draw dNch/deta
  • 0x0010 Draw alphas
  • 0x0020 Draw delta information
  • 0x0040 Draw backgrounds
  • 0x0100 Whether to make a PDF
  • 0x0200 Whether to pause after each plot
  • 0x0400 Draw in landscape
  • 0x0800 Alternative markers

By default, each plot will be made and the process paused. To advance, simple press the space-bar.

If we had made the histograms using ProofLite, we should do

gROOT->LoadMacro("AliTrackletAODUtils.C+g");
gROOT->LoadMacro("AliTrackletdNdeta2.C+g");
p->Run(0x8,0x3FF,9,
"LHC15o_245064_fp_dNdeta/AnalysisResult.root",
"LHC15k1a1_245064_fp_dNdeta/AnalysisResult.root",
"result.root");