Mid-rapidity tracklet code for dN/deta

Collaboration diagram for Mid-rapidity tracklet code for dN/deta:

Files
file	AliAODSimpleHeader.C
	A simplified AOD header.
file	AliAODTracklet.C
	Tracklet AOD object.
file	AliSimpleHeaderTask.C
	A task to make a simplified AOD header.
file	AliTrackletAODdNdeta.C
	AOD tasks to do final dN/deta in midrapidity.
file	AliTrackletAODTask.C
	Tasks to make tracklet AOD output.
file	AliTrackletAODUtils.C
	Utilities for midrapidity analysis.
file	AliTrackletdNdeta.C
	Post processing.
file	AliTrackletdNdeta2.C
	To post processing 2nd version.
file	AliTrackletWeights.C
	Encode simulation weights for 2nd pass.
file	CompareResults.C
	Compare different results.
file	ExtractGSE.C
	Extract GraphSysErr from results.
file	ExtractGSE2.C
	Extract GraphSysErr from results.
file	TrackletAODdNdeta.C
	A tracklet dNdeta train.
file	TrackletAODTrain.C
	Tracklet AOD train.
file	TryBuild.C

Classes
class	AliAODSimpleHeader
class	AliAODTracklet
class	AliAODMCTracklet
class	AliSimpleHeaderTask
class	AliTrackletAODdNdeta
class	AliTrackletAODMCdNdeta
class	AliTrackletAODWeightedMCdNdeta
class	AliTrackletAODTask
class	AliTrackletAODMCTask
class	AliTrackletAODUtils
struct	AliTrackletdNdeta
struct	AliTrackletdNdeta2
class	AliTrackletWeights
struct	TrackletAODdNdeta
struct	TrackletAODTrain

Detailed Description

• Overview
• To use
  • AOD production
  • Histogram production
  • Final result

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 is 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.

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/*/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=*/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");  
AliTrackletdNdeta2* p = new AliTrackletdNdeta2;
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)

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");  
AliTrackletdNdeta2* p = new AliTrackletdNdeta2;
p->Run(0x8,0x3FF,9,
       "LHC15o_245064_fp_dNdeta/AnalysisResult.root",
       "LHC15k1a1_245064_fp_dNdeta/AnalysisResult.root",
       "result.root");