AODTutorial
Analysis Tutorials
This is a modified version of the Analysis Tutorial 12.0.1 given by Ketevi
UppsalaAnalysisTutorial1201. Also we will look at his tutorial given in June 2005
analysis_on_aod.
Introduction
If you are not familiar with ATHENA, look at "Getting Started" in the ATLAS
WorkBook before proceeding further. You need an account of the CERN lxplus machines: if you do not already have an account on lxplus, apply for one as soon as possible - look at the ATLAS
WorkBook, "Getting Started" for details.
Set up CMT
- Login to lxplus at CERN and create a working directory called "Tutorial". We will use the release 12.0.1 this tutorial:
ssh lxplus.cern.ch
cd
mkdir Tutorial
cd Tutorial
mkdir 12.0.1
- Create a file called "requirements" and setup CMT. The requirements file looks like this where the working area for 12.0.1 is ${HOME}/scratch0/Tutorial/12.0.1:
#############################################################
set CMTSITE CERN
set SITEROOT /afs/cern.ch
macro ATLAS_DIST_AREA ${SITEROOT}/atlas/software/dist
macro ATLAS_GROUP_AREA "/afs/cern.ch/atlas/groups/PAT/Tutorial"
apply_tag simpleTest
apply_tag oneTest
macro ATLAS_TEST_AREA "" \
11.0.41 "${HOME}/scratch0/Tutorial/11.0.41" \
11.0.5 "${HOME}/scratch0/Tutorial/11.0.5" \
12.0.0 "${HOME}/scratch0/Tutorial/12.0.0" \
12.0.1 "${HOME}/scratch0/Tutorial/12.0.1"
use AtlasLogin AtlasLogin-* $(ATLAS_DIST_AREA)
#############################################################
Then do the following:
source /afs/cern.ch/sw/contrib/CMT/v1r18p20060301/mgr/setup.sh
cmt config
Setup for the release 12.0.1
Do the following:
source setup.sh -tag=12.0.1
Check that the CMT path is correct by doing this
echo $CMTPATH
Stuff like this should be printed to your screen:
/afs/cern.ch/user/k/ketevi/scratch0/Tutorial/12.0.1:
/afs/cern.ch/atlas/software/builds/AtlasOffline/12.0.1
You see that the path to your working directory, the path to the release directory and the external are set correctly - do not proceed unless this is done correctly.
Run Time Setup
Go to your working area and check out the follow package:
cd 12.0.1
cmt co -r UserAnalysis-00-08-01 PhysicsAnalysis/AnalysisCommon/UserAnalysis
Now compile everything as follows:
cd PhysicsAnalysis/AnalysisCommon/UserAnalysis/cmt
cmt config
source setup.sh
cmt broadcast gmake
cd ../run
To test that everything has been done correctly, do:
get_files HelloWorldOptions.py
athena.py -b HelloWorldOptions.py
Stuff like this should be printed to the screen:
HelloWorld INFO execute()
HelloWorld INFO An INFO message
HelloWorld WARNING A WARNING message
HelloWorld ERROR An ERROR message
HelloWorld FATAL A FATAL error message
AthenaEventLoopMgr INFO ===>>> end of event 9 <<<===
HistorySvc INFO Service finalised successfully
ChronoStatSvc.f... INFO Service finalized succesfully
ToolSvc INFO Removing all tools created by ToolSvc
ApplicationMgr INFO Application Manager Finalized successfully
ApplicationMgr INFO Application Manager Terminated successfully
The Next Time You Login
The next time you login, just do the following:
cd ${HOME}/scratch0/Tutorial
source setup.sh -tag=12.0.1
cd 12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/cmt
source setup.sh
cd ../run
Get The Necessary Files
We will use inclusive Z to mumu events (sample 4202), digitized in 11.0.41 but the ESD and AOD produced in the release 12.0.1. Copy the
PoolFileCatalog.xml
for the
AOD,
ESD and
Raw Data (RDO) into your
UserAnalysis "run" directory:
cp ~ketevi/scratch0/Tutorial/12.0.1/data/PoolFileCatalog.xml .
ls -lt ~ketevi/scratch0/Tutorial/12.0.1/data
cp ~ketevi/scratch0/Tutorial/12.0.1/data/*.py .
Run the AnalysisSkeleton
for 500 Events
get the necessary job options file from the release:
get_files AnalysisSkeleton_jobOptions.py
Edit
AnalysisSkeleton_jobOptions.py
and specify the input data to be the
AOD files that you just copied in the previous step: to do this, replace these lines
EventSelector.InputCollections = [
"AOD.pool.root"
]
with this line
include( "mc11.004201.ZeeJimmy.recon.AOD.v11000401.py" )
Check that in
AnalysisSkeleton_jobOptions.py
, the number of events to run is set to 500:
# Number of Events to process
theApp.EvtMax = 500
Now run the
AnalysisSkeleton_jobOptions.py
. It should produce a file called
AnalysisSkeleton.aan.root
which contains some
ROOT histograms and an
AthenaAwareNTuple :
athena.py -b AnalysisSkeleton_jobOptions.py
You've just produced the
AthenaAwareNTuple in a standalone way, directly on the
AOD, or the
ESD or even on the
RDO. For Further details on how to produce the
AthenaAwareNTuple in this way, follow this link:
AthenaAwareNTuple.
Now, you may look at the the
AnalysisSkeleton.h
, the
AnalysisSkeleton.cxx
and
AnalysisSkeleton_jobOptions.py
to see how the
ROOT histograms and the
AthenaAwareNTuple of the output file
AnalysisSkeleton.aan.root
are defined, filled and saved: Follow this link to the
AnalysisSkeleton. For further details on how to produces
ROOT histograms and Tuples in
ATHENA, look at the
THistSvc.
You should open the output file
AnalysisSkeleton.aan.root
in
ROOT and browse the histograms and the
AthenaAwareNTuple:
root AnalysisSkeleton.aan.root
b = TBrowser()
You will notice that beside the user-defined NTuple, the
AthenaAwareNTuple
tools add references to the AOD, ESD and Raw Data, in addition the
RunNumber
and the
EventNumber
.
More Information
For further details on the analysis tools, look at
PhysicsAnalysisTools. Details on the content of the ESD, the AOD and the TAG are on
StoregateKeysForESD,
StoregateKeysForAOD and
Atlas.TagForEventSelection.
If you successfully reach this point, you are ready for the tutorial, otherwise seek help. For true beginners, we will go through this
Introduction to the ATLAS software.
Z to mumu on AOD
In this exercise, we will do
Z to mumu
reconstruction on AOD: we will use the association objects
Analysis::Muon and its associated
TrackParticle. Proceed as follows: copy the code from this area, compiling and running it, then we go through it:
cd ../src
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/src/ZmumuOnAOD.cxx .
cd ../UserAnalysis
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/UserAnalysis/ZmumuOnAOD.h .
cd ../run
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/run/ZmumuOnAOD_jobOptions.py .
Now, you want to go the
src/components
directory and declare this new algorithm ZmumuOnAOD.
cd ../src/components
Edit UserAnalysis_entries.cxx and add these lines - follow the example that is already in there for the AnalysisSkeleton:
#include "UserAnalysis/ZmumuOnAOD.h"
DECLARE_ALGORITHM_FACTORY( ZmumuOnAOD )
DECLARE_ALGORITHM( ZmumuOnAOD )
Save UserAnalysis_entries.cxx and go back the cmt directory and compile:
cd ../../cmt
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/cmt/requirements .
cmt config
cmt broadcast gmake
cd ../run
Now you may run the ZmumuOnAOD algorithm as follows:
athena.py -b ZmumuOnAOD_jobOptions.py
This should produce an
AthenaAwareNTuple file,
ZmumuOnAOD.aan.root
. While Athena is running, let's go through the code by following this link:
ZmumuOnAOD for the details of the algorithm and the selection cuts.
Now, open this file in
ROOT and browse the
AthenaAwareNTuple:
root
TFile *_file0 = TFile::Open("ZmumuOnAOD.aan.root")
b = TBrowser()
TTree * zmumuOnAOD=(TTree*) gDirectory->Get("CollectionTree");
zmumuOnAOD->SetMarkerStyle(20)
zmumuOnAOD->SetMarkerSize(0.5)
zmumuOnAOD->SetMarkerColor(2)
zmumuOnAOD->SetLineColor(4)
zmumuOnAOD->SetLineWidth(2)
zmumuOnAOD->Draw("ZmmMass")
By default, we used the
Muonboy/STACO/MuTag association objects in the AOD and the associated
TrackParticles. But you may change it in the job options ZmumuOnAOD_jobOptions.py: the
StoreGate keys for the various objects in the AOD are listed here:
StoregateKeysForAOD.
Z to ee on AOD
In this exercise, we will do
Z to ee
reconstruction on AOD: we will use the association objects
Electron/Photon and its associated Electron
TrackParticle. Proceed as follows: copy the code from this area, compiling and running it, then we go through it:
cd ../src
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/src/ZeeOnAOD.cxx .
cd ../UserAnalysis
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/UserAnalysis/ZeeOnAOD.h .
cd ../run
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/run/ZeeOnAOD_jobOptions.py .
Now, you want to go the
src/components
directory and declare this new algorithm ZeeOnAOD.
cd ../src/components
Edit UserAnalysis_entries.cxx and add these lines - follow the example that is already in there for the AnalysisSkeleton:
#include "UserAnalysis/ZeeOnAOD.h"
DECLARE_ALGORITHM_FACTORY( ZeeOnAOD )
DECLARE_ALGORITHM( ZeeOnAOD )
Save UserAnalysis_entries.cxx and go back the cmt directory and compile:
cd ../../cmt
cmt config
cmt broadcast gmake
cd ../run
Now you may run the ZeeOnAOD algorithm as follows:
athena.py -b ZeeOnAOD_jobOptions.py
This should produce an
AthenaAwareNTuple file,
ZeeOnAOD.aan.root
. While Athena is running, let's go through the code by following this link:
ZeeOnAOD for the details of the algorithm and the selection cuts.
Now, open this file in
ROOT and browse the
AthenaAwareNTuple:
root
TFile *_file0 = TFile::Open("ZeeOnAOD.aan.root")
b = TBrowser()
TTree * zmumuOnAOD=(TTree*) gDirectory->Get("CollectionTree");
zeeOnAOD->SetMarkerStyle(20)
zeeOnAOD->SetMarkerSize(0.5)
zeeOnAOD->SetMarkerColor(2)
zeeOnAOD->SetLineColor(4)
zeeOnAOD->SetLineWidth(2)
zeeOnAOD->Draw("ZeeMass")
ZeeOnAOD->Draw("ElectronIsEM")
The
StoreGate keys for the various objects in the AOD are listed here:
StoregateKeysForAOD.
The TrackParticle
In this exercise, we will access a collection of
TrackParticles directly from the AOD. Note that from the association objects,
Analysis::Muon or
Electron, you can access the various associated
TrackParticles, e.g., look in
AnalysisMuon.cxx
. But in this exercise, we will use one collection of
TrackParticles in the AOD. You may proceed as follows, then we go through the code:
cd ../src
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/src/TrackExample.cxx .
cd ../UserAnalysis
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/UserAnalysis/TrackExample.h .
cd ../run
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/run/TrackExample_jobOptions.py .
Now, you want to go the
src/components
directory and declare this new algorithm TrackExample.
cd ../src/components
edit UserAnalysis_entries.cxx and add these lines
(follow the example that is already in there for the AnalysisSkeleton and AnalysisMuon):
#include "UserAnalysis/TrackExample.h"
DECLARE_ALGORITHM_FACTORY( TrackExample )
DECLARE_ALGORITHM( TrackExample )
Save UserAnalysis_entries.cxx and go back the cmt directory and compile:
cd ../../cmt
cmt config
cmt broadcast gmake
cd ../run
Now you may run the TrackExample algorithm as follows:
athena.py -b TrackExample_jobOptions.py
You should have an
AthenaAwareNTuple file,
TrackExample.aan.root
. While Athena is running, let's go through the code by following this link:
KeteviAnalysis. Note the log output to the screen: you will see that the perigee information and the track summary information are being printed to the screen. Look at
TrackExample.cxx in details to see how to access this information and more from the
TrackParticle.
Now, open this file in
ROOT and browse the
AthenaAwareNTuple:
root
TFile *_file0 = TFile::Open("TrackExample.aan.root")
b = TBrowser()
TTree * trackExample=(TTree*) gDirectory->Get("CollectionTree");
trackExample->SetMarkerStyle(20)
trackExample->SetMarkerSize(0.5)
trackExample->SetMarkerColor(2)
trackExample->SetLineColor(4)
trackExample->SetLineWidth(2)
trackExample->Draw("TrackPEta")
trackExample->Draw("TrackPD0")
trackExample->Draw("TrackPZ0:TrackPD0")
In this example, we used the Inner Detector collection of
TrackParticle in AOD, with
StoreGate key "TrackParticleCandidate": follow this link for the AOD content and the keys for various objects/containers int the AOD -
StoregateKeysForAOD.
Event Selection with TAG or AAN
In this exercise, we will use the TAG and the
AthenaAwareNTuple to select the final states of interest. For details on the TAG based event selection, follow this link:
Atlas.TagForEventSelection.
Event Selection with the TAG
In this exercise, we will use the TAG to select the final states of interest. These data contain Z to mumu so there is not selection of final state we can do with the TAG on this data but this exercise will give a flavor of what you can do with the TAG and how to do it. Consider the following job options.
####################################################
#Author - Ketevi A. Assamagan
AllAlgs = False
doHist = False
doCBNT = False
doWriteTAG = False
doWriteESD = False
readAOD = True
doAOD = False
doWriteAOD = True
# read the TAG as input to the job
readColl = True
# Number of Events
EvtMax = 20
# Use the TAG that you just produce to select the events
# define also the selection criteria
include ( "mc11.004202.ZmumuJimmy.recon.TAG.v11000401.py" )
CollInputQuery="NLooseMuon>0 && NLooseMuon<3 && abs(LooseMuonEta1)<2.5 && abs(LooseMuonEta2)<2.5 && LooseMuonPt2>10000 && LooseMuonPt2>10000"
#Create a new RDO, ESD and AOD that contain only selected events
PoolAODOutput = "mc11.004202.ZmumuJimmy.recon.AOD.TagSel.v11000401.root"
# main reconstruction job jobOptions
include ("RecExCommon/RecExCommon_topOptions.py")
#######################################################
Create a file called
TagBasedEventSelection_topOptions.py
and copy the above options into it and save it. We are using the TAG file as input and selecting the events at the AOD level. Our selection criteria are defined in the
CollInputQuery
. We are querying for the events having:
Two one or 2 loose muons
Eta of each loose muons within 2.5
Pt of 2 loose muons above 10 GeV - unit in MeV
For the all the events that pass the selection, we create an AOD file that contains ONLY the selected events: for details on how to use the TAG and which TAG content or attributes you can make selection on, follow this link:
Atlas.TagForEventSelection. The new AOD file name should be
mc11.004202.ZmumuJimmy.recon.AOD.TagSel.v11000401.root
as specified in the above job options. To select events at the ESD level, one would simply add this lines:
readESD = True
readAOD = False
Now run this job options and see that you have a new AOD file that contains only the selected events.
An easy and a quick way to see the TAG attributes is to just open the TAG file in
ROOT and browse. Copy a sample TAG file from my area and open it in
ROOT:
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/run/TAG.fromAOD.pool.root .
root TAG.fromAOD.pool.root
b=TBrowser()
Now you can do analysis on the new AOD that contains ONLY the selected events.
In this exercise, we will use the
AthenaAwareNTuple that you produced in the introdcution: you should have an NTuple called
AnalysisSkeleton.aan.root
. Proceed as follows:
cp AnalysisSkeleton_jobOptions.py AanSelectionAnalysis_topOptions.py
Edit
AanSelectionAnalysis_topOptions.py
and replace this line
include( "mc11.004201.ZeeJimmy.recon.AOD.v11000401.py" )
with these lines
EventSelector.InputCollections = [ "AnalysisSkeleton.aan" ]
EventSelector.Query="NElectrons>0 && NElectrons<3 && abs(ElectronEta[0])<2.5 && abs(ElectronEta[1])<2.5 && ElectronPt[0]>10000 && ElectronPt[1]>10000"
EventSelector.CollectionType = "ExplicitROOT"
Here, we are using the
AthenaAwareNTuple called
AnalysisSkeleton.aan.root
to selected the event at the AOD. Then, we are run the Analysis code,
AnalysisSkeleton.cxx
on the selected events. Note that when you use the TAG or the
AthenaAwareNTuple to event selection, the file extension
.root
must not be specified: it is assumed and will be appended. In these exercises, we are using the ROOT version of the TAG --- also, our
AthenaAwareNTuple is a ROOT file. This is why we specify the
CollectionType
to be
ExplicitROOT
. There is also a database version of the TAG: for details see
Atlas.TagForEventSelection. In
AanSelectionAnalysis_topOptions.py
, replace these lines
THistSvc.Output = ["AANT DATAFILE='AnalysisSkeleton.aan.root' OPT='RECREATE'"]
AANTupleStream.OutputName = 'AnalysisSkeleton.aan.root'
with these lines:
THistSvc.Output = ["AANT DATAFILE='AnalysisSkeleton.sel.aan.root' OPT='RECREATE'"]
AANTupleStream.OutputName = 'AnalysisSkeleton.sel.aan.root'
Now run:
athena.py -b AanSelectionAnalysis_topOptions.py
You should have a new
AthenaAwareNTuple file called
AnalysisSkeleton.sel.aan.root
. That we've just done is the following: we use a previously available
AthenaAwareNTuple or TAG to select events and we did analysis on the selected events creating a new
AthenaAwareNTuple. We also saw that it is possible to create a new AOD that contains ONLY the selected events. Now check that the selection criteria that we specified above were indeed apply: open
AnalysisSkeleton.sel.aan.root
and plot the
EventNumber
and the
NElectrons
(this should be one or two) according to our selection criteria.
Z to mumu on the ESD
In this exercise, we will use the ESD muon association objects,
CombinedMuon and its associated
TrackParticle and
Trk::Track to repeat the
Z to mumu
reconstruction entirely on ESD and compare to the results of the AOD above. Proceed as you've done above by copying the code from my area, compiling and running it, then we go through it:
cd ../src
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/src/ZmumuOnESD.cxx .
cd ../UserAnalysis
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/UserAnalysis/ZmumuOnESD.h .
cd ../run
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/run/ZmumuOnESD_jobOptions.py .
Now, you want to go the
src/components
directory and declare this new algorithm ZmumuOnESD.
cd ../src/components
edit UserAnalysis_entries.cxx and add these lines
(follow the example that is already in there for the AnalysisSkeleton, AnalysisMuon and TrackExample):
#include "UserAnalysis/ZmumuOnESD.h"
DECLARE_ALGORITHM_FACTORY( ZmumuOnESD )
DECLARE_ALGORITHM( ZmumuOnESD )
Save UserAnalysis_entries.cxx and go back the cmt directory and compile:
cd ../../cmt
cmt config
cmt broadcast gmake
cd ../run
Now you may run the ZmumuOnESD algorithm as follows:
athena.py -b ZmumuOnESD_jobOptions.py
This should produce an
AthenaAwareNTuple file,
ZmumuOnESD.aan.root
. While Athena is running, let's go through the code by following this link:
ZmumuOnESD.cxx for the details of the algorithm and the selection cuts.
Now, open this file in
ROOT and browse the
AthenaAwareNTuple:
root
TFile *_file0 = TFile::Open("ZmumuOnESD.aan.root")
b = TBrowser()
TTree * zmumuOnESD=(TTree*) gDirectory->Get("CollectionTree");
zmumuOnESD->SetMarkerStyle(20)
zmumuOnESD->SetMarkerSize(0.5)
zmumuOnESD->SetMarkerColor(2)
zmumuOnESD->SetLineColor(4)
zmumuOnESD->SetLineWidth(2)
zmumuOnESD->Draw("ESDZmmMass")
zmumuOnESD->Draw("ESDZmmDeltaR")
By default, we used the
Muonboy/STACO/MuTag association objects in the ESD and the associated
TrackParticles and
Trk::Track. But you may change it in the job options ZmumuOnESD_jobOptions.py: the
StoreGate keys for the various objects in the ESD are listed here:
StoregateKeysForESD. You will notice that in ZmumuOnESD_jobOptions.py, the input data is the ESD, and we are using the
CombinedMuonContainer with
StoreGate key "StacoCombinedMuonContainer" and from each
CombinedMuon object, you can access the associated
TrackParticles and
Trk::Track.
Plot the mumu invariant mass obtained on the ESD and compare it to the one obtained on the AOD above - there may be some differences that I will leave up to you to figure out.
Z to ee on the ESD
In this exercise, we will use the ESD Electron/Photon association objects,
egamma and its associated
TrackParticle and
CaloCluster to repeat the
Z to ee
reconstruction entirely on ESD and compare to the results of the AOD above. Proceed as you've done above by copying the code from my area, compiling and running it, then we go through it:
cd ../src
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/src/ZeeOnESD.cxx .
cd ../UserAnalysis
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/UserAnalysis/ZeeOnESD.h .
cd ../run
cp ~ketevi/scratch0/Tutorial/12.0.1/PhysicsAnalysis/AnalysisCommon/UserAnalysis/run/ZeeOnESD_jobOptions.py .
Now, you want to go the
src/components
directory and declare this new algorithm ZeeOnESD.
cd ../src/components
edit UserAnalysis_entries.cxx and add these lines
(follow the example that is already in there for the AnalysisSkeleton, AnalysisMuon and TrackExample):
#include "UserAnalysis/ZeeOnESD.h"
DECLARE_ALGORITHM_FACTORY( ZeeOnESD )
DECLARE_ALGORITHM( ZeeOnESD )
Save UserAnalysis_entries.cxx and go back the cmt directory and compile:
cd ../../cmt
cmt config
cmt broadcast gmake
cd ../run
Now you may run the ZeeOnESD algorithm as follows:
athena.py -b ZeeOnESD_jobOptions.py
This should produce an
AthenaAwareNTuple file,
ZeeOnESD.aan.root
. While Athena is running, let's go through the code by following this link:
ZeeOnESD.cxx for the details of the algorithm and the selection cuts.
Now, open this file in
ROOT and browse the
AthenaAwareNTuple:
root
TFile *_file0 = TFile::Open("ZeeOnESD.aan.root")
b = TBrowser()
TTree * zeeOnESD=(TTree*) gDirectory->Get("CollectionTree");
zeeOnESD->SetMarkerStyle(20)
zeeOnESD->SetMarkerSize(0.5)
zeeOnESD->SetMarkerColor(2)
zeeOnESD->SetLineColor(4)
zeeOnESD->SetLineWidth(2)
zeeOnESD->Draw("EgammaPt")
zeeOnESD->Draw("EgammaEta")
zeeOnESD->Draw("EgammaEoverP")
zeeOnESD->Draw("EgammaIsEM")
zeeOnESD->Draw("EgammaZeeMass")
zeeOnESD->Draw("EgammaTrackP")
zeeOnESD->Draw("EgammaClusterE")
The
StoreGate keys for the various objects in the ESD are listed here:
StoregateKeysForESD. You will notice that in ZeeOnESD_jobOptions.py, the input data is the ESD, and we are using the
egammaContainer with
StoreGate key "egammaCollection" and from each
egamma object, you can access the associated
TrackParticles and
CaloCluster.
Plot the ee invariant mass obtained on the ESD and compare it to the one obtained on the AOD above - there may be some differences that I will leave up to you to figure out.
For further details of the Electron/Photon reconstruction, see
egammaRec.
Interactive Analysis in ATHENA
In this exercise, we will see how to do interactive analysis in ATHENA, how to browse the Raw Data in the AOD. Proceed as follows:
get_files Interactive_topO.py
Edit
Interactive_topO.py
and replace this line
EventSelector.InputCollections = [ "AOD.pool.root" ]
with this line:
include( "mc11.004100.T1_McAtNLO_top.recon.AOD.v11000401.py" )
Then start the interactive analysis session
from this link.
Monte Carlo Truth Tools on AOD
In this exercise, we will look MC Truth Tools on AOD.
Follow the link below, but skip the configuration part since it pertains to the release 11.0.5 while we are using the release 12.0.1 here and we have already done the configuration for 12.0.1 in the Introduction above. You will also need to make the following changes for 12.0.1: everywhere where application, replace the following
#include "TruthParticleAlgs/McVtxFilterTool.h"
#include "TruthParticleAlgs/TruthParticleCnvTool.h"
#include "AnalysisUtils/McVtxFilter.h"
#include "ParticleEvent/TruthParticle.h"
#include "ParticleEvent/TruthParticleContainer.h"
with the following:
#include "McParticleTools/McVtxFilterTool.h"
#include "McParticleTools/TruthParticleCnvTool.h"
#include "McParticleUtils/McVtxFilter.h"
#include "McParticleEvent/TruthParticle.h"
#include "McParticleEvent/TruthParticleContainer.h"
Also in your requirements file, you may need to add the following lines and redo
cmt config
and
gmake
:
cmt co -r McParticleTools McParticleTools-00-* PhysicsAnalysis/TruthParticleID
cmt co -r McParticleUtils McParticleUtils-00-* PhysicsAnalysis/TruthParticleID
cmt co -r McParticleEvent McParticleEvent-00-* PhysicsAnalysis/TruthParticleID
Now follow this link, McTrtuh on AOD, make sure that you make the above modifications before running.
Trigger-Aware Analysis
A tutorial on Trigger-Aware Analysis can be found
here: it was given in 11.0.5 and it is being updated for the release 12.
Major updates:
--
KeteviAssamagan - 06 Jul 2006
--
TheodotaLagouri - 29 Sep 2006