PAT Exercise 07: PFBRECO Tutorial

Objectives

PFBRECO (formerly called PF2PAT) is a set of tools, that you are free to use, or not.

This tutorial will teach you:

  • What the default sequence of PFBRECO is doing
  • How you can tune the PFBRECO sequence to your analysis
  • How to keep track of what you are doing using:
    • edmConfigBrowser
    • the EDM event as an ntuple in ROOT

ALERT! Note:

This web course is part of the PAT Tutorial, which takes regularly place at cern and in other places. When following the PAT Tutorial the answers of questions marked in RED should be filled into the exercise form that has been introduced at the beginning of the tutorial. Also the solutions to the Exercises should be filled into the form. The exercises are marked in three colours, indicating whether this exercise is basic (obligatory), continuative (recommended) or optional (free). The colour coding is summarized in the table below:

Color Code Explanation
red Basic exercise, which is obligatory for the PAT Tutorial.
yellow Continuative exercise, which is recommended for the PAT Tutorial to deepen what has been learned.
green Optional exercise, which shows interesting applications of what has been learned.

Basic exercises ( red ) are obliged and the solutions to the exercises should be filled into the exercise form during the PAT Tutorial.

Setting up of the environment

First of all connect to lxplus or cmslpc and go to some work directory. You can choose any directory, provided that you have enough space. You need ~100 MB of free disk space for this exercise. We recommend you to use your ~/scratch0 space. In case you don't have this (or do not even know what it is) check your quota typing fs lq and follow this link. If you don't have enough space, you may instead use the temporary space ( /tmp/your_user_name), but be aware that this is lost once you log out of lxplus (or within something like a day). We will expect in the following that you have such a ~/scratch0 directory.

ssh lxplus
[ ... enter password ... ]
cd scratch0/

Create a directory for this exercise (to avoid interference with code from the other exercises).

mkdir exercise07
cd exercise07

Create a local release area and enter it. Then:

export SCRAM_ARCH=slc5_amd64_gcc462
cmsrel CMSSW_7_4_1_patch4
cd CMSSW_7_4_1_patch4/src 
cmsenv
addpkg PhysicsTools/PatAlgos
scram b -j 9

Having a look at the PAT configuration file

The basic configuration file we are going to use is

PhysicsTools/PatAlgos/test/patTuple_PFBRECO_cfg.py

It will run the standard PFBRECO sequence on a standard AOD/RECO input. Having a look into this file with your favourite editor you will see (leaving out some comments and general things you should recognize from prior exercises):

# load the PAT config
process.load("PhysicsTools.PatAlgos.patSequences_cff")

# Configure PAT to use PFBRECO instead of AOD sources
# this function will modify the PAT sequences. 
from PhysicsTools.PatAlgos.tools.pfTools import *

postfix = "PFlow" jetAlgo="AK5" 
usePFBRECO(process,runPFBRECO=True, jetAlgo=jetAlgo, runOnMC=True, postfix=postfix) 
# to run second PFBRECO+PAT with different postfix uncomment the following lines
# and add the corresponding sequence to the path
#postfix2 = "PFlow2"
#jetAlgo2="AK7"
#usePFBRECO(process,runPFBRECO=True, jetAlgo=jetAlgo2, runOnMC=True, postfix=postfix2) 

# to use tau-cleaned jet collection uncomment the following: 
#getattr(process,"pfNoTau"+postfix).enable = True

# to switch default tau to HPS tau uncomment the following: 
#adaptPFTaus(process,"hpsPFTau",postfix=postfix)

# Let it run 
process.p = cms.Path( 
# process.patDefaultSequence + 
getattr(process,"patPFBRECOSequence"+postfix) 
# second PFBRECO 
# + getattr(process,"patPFBRECOSequence"+postfix2) 
) 

Basically, what is done is the following:

  • The standard PAT sequence which you have run several times already is loaded.
  • The usePFBRECO function is used to create the PFBRECO+PAT sequence. This sequence contains:
    • the PFBRECO sequence
    • a modified PAT sequence. This sequence is obtained by cloning the standard PAT sequence, and by connecting the clone to the output of the PFBRECO sequence.
  • The PFBRECO+PAT sequence is added to the path.

Exercises

Exercise 7 a): Understand the PFBRECO sequence

cd PhysicsTools/PatAlgos/test 
edmConfigBrowser patTuple_PFBRECO_cfg.py

In the left panel, open:

  • paths (all paths)
    • p (the p path)
      • patPFBRECOSequencePFlow (the PFBRECO+PAT sequence)
        • PFBRECOPFlow (the PFBRECO+PAT sequence)
          • pfMuonSequencePFlow (the PFBRECO muon sequence). You should select this sequence, not only open it in the left panel, so that all the modules in this sequence are displayed in the middle panel.

Click on the various modules in the middle panel, and look at the parameters.

Question Question 7 a):

  • What are the various selections applied on the muon PFCandidates in the pfMuonSequencePFlow sequence?
  • Double-click on pfAllMuonsPFlow, to navigate back. What are the selections applied to the muon PFCandidates before entering the pfMuonSequencePFlow sequence?
  • Navigate back as much as you can, to pfPileUpPFlow. What is the input collection of this module? Why don't we see the previous modules in the edmConfigBrowser?

Exercise 7 b): A small analysis of jets in Z ->

cd PhysicsTools/PatAlgos/test 
cp patTuple_PFBRECO_cfg.py muons_PFBRECO_cfg.py

opening muons_PFBRECO_cfg.py in your favorite editor, find the following commented line, uncomment it, and change the path of the sample file as given below:

process.source.fileNames = [ 
 '/store/relval/CMSSW_5_2_5_cand1/RelValZMM/GEN-SIM-RECO/START52_V9-v1/0261/A6667CAA-7091-E111-82F0-00261894389C.root'
] 

Now run the PFBRECO+PAT process on these Z mu mu events:

cmsRun muons_PFBRECO_cfg.py

A small hint by the way: to keep the shell unblocked, you can also pipe the output to a logfile and watch it with 'tail' (-f means follow).

cmsRun muons_PFBRECO_cfg.py &> muons_PFBRECO_cfg.log &
tail -f muons_PFBRECO_cfg.log

TIP Warnings of the following kind are harmless:

 
WARNING: called applyPostfix for module/sequence cleanPatTaus which is not in patDefaultSequencePFlow!
MET: using  cms.InputTag("pfMETPFlow")
WARNING: called applyPostfix for module/sequence patCandidates which is not in patDefaultSequencePFlow!
WARNING: called applyPostfix for module/sequence patCandidates which is not in patDefaultSequencePFlow!

Open ROOT, load FWLite, and make a few plots:

root
.L $CMSSW_RELEASE_BASE/src/CommonTools/ParticleFlow/test/Macros/rootlogon.C
loadFWLite()
TFile f("patTuple_PFBRECO.root")
initPAT("PAT")

new TCanvas("muons_pt","muons_pt")
Events.Draw("selectedPatMuonsPFlow.pt()")
new TCanvas("muons_iso","muons_iso")
Events.Draw("(selectedPatMuonsPFlow.chargedHadronIso() + selectedPatMuonsPFlow.photonIso() + selectedPatMuonsPFlow.neutralHadronIso()) / selectedPatMuonsPFlow.pt()")
new TCanvas("jets_pt","jets_pt")
Events.Draw("selectedPatJetsPFlow.pt()")

Question Question 7 b):

  • Can you explain the shape of muon isolation distribution
  • Can you explain the shape of the jet pT distribution?

TIP Physics questions might become easier with higher statistics (here: maybe 300 events), because bumps get more obvious.

TIP You may want to use this rootlogon.C as your rootlogon, see the ROOT documentation.

As you can see from here on you can use the PAT objects built during PFBRECO just like you have learned during the previous exercises.

Now let us change the event hypothesis in the most basic way: only let global muons with pT > 50 GeV pass as muons. Also set the minimal isolation to 0.1. At the end of muons_PFBRECO_cfg.py, add the lines:

#global muon pt>50 GeV 
process.pfSelectedMuonsPFlow.cut = 'pt>50 & muonRef().isNonnull & muonRef().isGlobalMuon()' 
#isolation cut to 0.1 
process.pfIsolatedMuonsPFlow.isolationCut = 0.1 

Warning, important Note: The selection in pfSelectedMuonsPFlow is done on a reco::PFCandidate and not on a pat::Muon. This means you have to be careful, for example, when cutting on muon quantities, to first check that the reference to the reco::Muon is available in the PFCandidate.

Run cmsRun again, and repeat the plotting above.

Question Question 7 c):

  • Can you explain the little bump that appeared in the jet pT distribution?
  • Can you explain the shape of the muon isolation distribution?
  • Conclusion: which PFCandidates of type muon end up as pat::Muons? in pat::Jets?

Now remove the lines you have added at the end of your cfg. At the end of your cfg, add:

# relaxing completely the muon isolation in PFBRECO
process.pfIsolatedMuonsPFlow.isolationCut = 9999999
And set the following parameter to False (the line is already present in the cfg):
getattr(process,"pfNoMuon"+postfix).enable = False 

Question Question 7 d):

  • Can you explain the little bump that appeared in the jet pT distribution?
  • Can you explain the shape of the muon isolation distribution?
  • Conclusion: which PFCandidates of type muon end up as pat::Muons? in pat::Jets?

Question Question 7 e):
Should you modify any of the PAT producers before calling the function usePFBRECO(...)?

Exercise 7 c): Run PFBRECO+PAT and standard PAT at the same time

cd PhysicsTools/PatAlgos/test 
cp patTuple_PATandPFBRECO_cfg.py  muons_PATandPFBRECO_cfg.py

Edit muons_PATandPFBRECO_cfg.py and change the source to read the Z to mu mu RelVal sample, as explained in A small analysis of jets in Z -> . Then, run:

cmsRun muons_PATandPFBRECO_cfg.py

A file called patTuple_PATandPFBRECO.root is produced. Check the collections stored in this file:

edmFileUtil -P -f file:patTuple_PATandPFBRECO.root

Result:

file:patTuple_PATandPFBRECO.root
file:patTuple_PATandPFBRECO.root (1 runs, 3 lumis, 332 events, 13649035 bytes)
Branch 0 of Events tree: EventAuxiliary Total size = 52474
Branch 1 of Events tree: EventBranchEntryInfo Total size = 9112112
Branch 2 of Events tree: EventSelections Total size = 29038
Branch 3 of Events tree: BranchListIndexes Total size = 7918
Branch 4 of Events tree: recoPFCandidates_particleFlow__RECO. Total size = 17766110
Branch 5 of Events tree: recoPFCandidates_particleFlow_AddedMuonsAndHadrons_RECO. Total size = 16036
Branch 6 of Events tree: recoPFCandidates_particleFlow_CleanedCosmicsMuons_RECO. Total size = 16005
Branch 7 of Events tree: recoPFCandidates_particleFlow_CleanedFakeMuons_RECO. Total size = 15912
Branch 8 of Events tree: recoPFCandidates_particleFlow_CleanedHF_RECO. Total size = 15695
Branch 9 of Events tree: recoPFCandidates_particleFlow_CleanedPunchThroughMuons_RECO. Total size = 16160
Branch 10 of Events tree: recoPFCandidates_particleFlow_CleanedPunchThroughNeutralHadrons_RECO. Total size = 16439
Branch 11 of Events tree: recoPFCandidates_particleFlow_CleanedTrackerAndGlobalMuons_RECO. Total size = 16284
Branch 12 of Events tree: recoPFCandidates_particleFlow_electrons_RECO. Total size = 95209
Branch 13 of Events tree: recoBaseTagInfosOwned_selectedPatJets_tagInfos_PAT. Total size = 24453
Branch 14 of Events tree: recoBaseTagInfosOwned_selectedPatJetsPFlow_tagInfos_PAT. Total size = 24693
Branch 15 of Events tree: CaloTowers_selectedPatJets_caloTowers_PAT. Total size = 1119715
Branch 16 of Events tree: CaloTowers_selectedPatJetsPFlow_caloTowers_PAT. Total size = 125771
Branch 17 of Events tree: patElectrons_selectedPatElectrons__PAT. Total size = 798232
Branch 18 of Events tree: patElectrons_selectedPatElectronsPFlow__PAT. Total size = 728360
Branch 19 of Events tree: patJets_selectedPatJets__PAT. Total size = 2542374
Branch 20 of Events tree: patJets_selectedPatJetsPFlow__PAT. Total size = 4535426
Branch 21 of Events tree: patMETs_patMETs__PAT. Total size = 441300
Branch 22 of Events tree: patMETs_patMETsPFlow__PAT. Total size = 393983
Branch 23 of Events tree: patMuons_selectedPatMuons__PAT. Total size = 2991920
Branch 24 of Events tree: patMuons_selectedPatMuonsPFlow__PAT. Total size = 2604909
Branch 25 of Events tree: patPFParticles_selectedPatPFParticlesPFlow__PAT. Total size = 12905989
Branch 26 of Events tree: patPhotons_selectedPatPhotons__PAT. Total size = 385170
Branch 27 of Events tree: patTaus_selectedPatTaus__PAT. Total size = 6671750
Branch 28 of Events tree: patTaus_selectedPatTausPFlow__PAT. Total size = 623866
Branch 29 of Events tree: recoGenJets_selectedPatJets_genJets_PAT. Total size = 374327
Branch 30 of Events tree: recoGenJets_selectedPatJetsPFlow_genJets_PAT. Total size = 654016
Branch 31 of Events tree: recoPFCandidates_selectedPatJetsPFlow_pfCandidates_PAT. Total size = 3825428

All the branches for which the module name ends by PFlow are from PFBRECO+PAT . The other branches are from standard PAT. Let's compare the two pat::Muon collections using ROOT.

root
.L $CMSSW_RELEASE_BASE/src/CommonTools/ParticleFlow/test/Macros/rootlogon.C
loadFWLite()
TFile f("patTuple_PATandPFBRECO.root")

Events.Draw("patMuons_selectedPatMuons__PAT.obj.pt()>>h1")
Events.Draw("patMuons_selectedPatMuonsPFlow__PAT.obj.pt()>>h2","","same")
h1.Draw()
h2.SetLineColor(2)
h2.Draw("same")

To understand these plots, one should note that:

  • standard PAT pat::Muons are built from all reco::Muons in the event. The fake rate is rather large, and non-isolated muons are included.
  • PFBRECO+PAT pat::Muons are built from isolated PFCandidates of type muon, with a pT larger than 5 GeV/c. These PFCandidates are reconstructed in the particle flow algorithm from the same reco::Muons as in the standard PAT case. The muon identification in the particle flow algorithm ensures a low fake rate, and the isolation requirement in PFBRECO removes muons in jets, for instance from heavy flavour leptonic decay. These muons are clustered in the jets together with the other particles, and don't give rise to pat::Muons. Instead, they end up in the pat::Jets.

Question Question 7 f):

  • Did you notice any change in processing time with respect to PFBRECO+PAT alone? How can you explain it?
  • What is the cause for the peak at low pT in the standard pat::Muon plot?
  • Why is the efficiency at high pT lower in the case of PFBRECO+PAT than in standard PAT?

Save your plot by doing:

gPad.SaveAs("Plot_muonpt_PATandPFBRECO.png")
gPad.SaveAs("Plot_muonpt_PATandPFBRECO.root")

Let us investigate the effect of the isolation cut in PFBRECO on the PFBRECO+PAT muon efficiency. Edit muons_PATandPFBRECO_cfg.py and add the following line at the end of the file to fully relax the muon isolation cut

#relaxed isolation 
process.pfIsolatedMuonsPFlow.isolationCut = 999.0 
  • re-run PFBRECO+PAT,
  • redo the plot, and compare to the previous one.

Question Question 7 g):
What is the main source of muon inefficiency in the PFBRECO+PAT sequence?

A small loss of efficiency is still visible at high pT for PFBRECO+PAT muons, with respect to standard PAT muons. The subject of the next exercise is to understand this loss.

Exercise 7 d): Understanding the PFBRECO muon efficiency

Start edmConfigBrowser on the file you have created in the previous exercise:

edmConfigBrowser muons_PATandPFBRECO_cfg.py

In the left panel, open:

  • paths (all paths)
    • p (the p path)
      • patPFBRECOSequencePFlow (the PFBRECO+PAT sequence)
        • PFBRECOPFlow (the PFBRECO+PAT sequence)
          • pfMuonSequencePFlow (the PFBRECO muon sequence)

Question Question 7 h):

  • Which module(s) could be the reason for the small loss in efficiency observed at high muon pT in the previous exercise? Test your hypotheses by modifying the configuration of the module(s) you suspect to be responsible for the loss, before rerunning PFBRECO+PAT and redoing the plots.

It can be that the muons are lost before PFBRECO+PAT, in the particle flow algorithm. We're going to check the muon PFCandidates at the output of the particle flow algorithm, to see if some reco::Muons are already missing. To do that, we are going to use a module already present in the pfMuonSequencePFlow. We'll clone this module, and plug the clone where we need it.

# at the end of your cfg, clone the pfAllMuons module, and plug it to the collection of PFCandidates from RECO:
process.pfAllMuons2 = process.pfAllMuonsPFlow.clone() 
process.pfAllMuons2.src = 'particleFlow'

# add it to your path: 
process.p += process.pfAllMuons2

# keep the resulting collection in your output file: 
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning 
process.out.outputCommands.append('keep recoPFCandidates_pfAllMuons2_*_*') 

Now, rerun the cfg.

Question Question 7 i):

  • Within ROOT, compare the pT spectrum of the muon PFCandidates you have selected to the pT spectrum of the standard PAT muons, which are directly built from the collection of reco::Muons. Is PFBRECO responsible for this small loss of efficiency at high pT? Where could this loss occur?

Exercise 7 e): Using the particle-based isolation computed in PFBRECO

First prepare your cfg.

cd PhysicsTools/PatAlgos/test 
cp patTuple_PFBRECO_cfg.py isolation_PFBRECO_cfg.py

Edit isolation_PFBRECO_cfg.py and change the source to read the Z to mu mu RelVal sample, as explained in A small analysis of jets in Z -> . Then, run:

cmsRun isolation_PFBRECO_cfg.py

Now let's have a look at the muon isolation. Plot the isolation values computed in the PFBRECO sequence, and stored in the pat lepton (third last). Plot the relative, combined isolation computed in the PFBRECO sequence, used to select the PF muons that will make it to pat::Muons (last two).

root
.L $CMSSW_RELEASE_BASE/src/CommonTools/ParticleFlow/test/Macros/rootlogon.C
loadFWLite()
TFile f("patTuple_PFBRECO.root")

Events.Draw("patMuons_selectedPatMuonsPFlow__PAT.obj.chargedHadronIso()")

Events.SetAlias("mu","patMuons_selectedPatMuonsPFlow__PAT.obj")
Events.Draw("(mu.chargedHadronIso()+mu.photonIso()+mu.neutralHadronIso() ) / mu.pt()")

Question Question 7 j):
Set your canvas to log scale on the vertical axis. Where does the relative, combined isolation distribution stop? why?

The isolation value can also be recomputed on the fly, using the IsoDeposits stored in the pat lepton. Plot the sum pT of charged hadrons in a cone of 0.4 around the muon, computed from the IsoDeposits:

Events.Draw("patMuons_selectedPatMuonsPFlow__PAT.obj.isoDeposit(4).depositWithin(0.4)")

Note that the result is the same as when the pre-computed charged hadron isolation value is used.

The IsoDeposits made from particle-flow photons and neutral hadrons can be accessed in the same way, by changing the requested type of IsoDeposit (equal to 4 to access charged hadron IsoDeposits, and given as an argument of the isoDeposit function). The available types are defined in DataFormats/PatCandidates/interface/Isolation.h.

Exercises:

  • plot the sum pT of neutral hadrons in a cone of 0.5 around the muon
  • plot the sum pT of photons in a cone of 0.5 around the muon
  • plot the sum pT of charged hadrons in a cone of 0.5 around the muon

Question Question 7 k):
Which kind of particle (charged hadron, neutral hadron, photon) is contributing the most to the energy in the isolation cone? Why?

Exercise 7 f): Decoupling particle-based isolation and apply dbeta correction in PFBRECO

First prepare your cfg.

cd PhysicsTools/PatAlgos/test 
cp patTuple_PFBRECO_cfg.py noisolation_PFBRECO_cfg.py

opening noisolation_PFBRECO_cfg.py in your favorite editor, find the following commented line, uncomment it, and change the path of the sample file as given below:

process.source.fileNames = [ 
  '/store/data/Run2011B/DoubleMu/AOD/PromptReco-v1/000/180/072/0825E2B2-0C03-E111-BBB5-BCAEC518FF5F.root'
] 

This is data sample. So don't forget to set runOnMC=False

usePFBRECO(process,runPFBRECO=True, jetAlgo=jetAlgo, runOnMC=False, postfix=postfix)

Now replace isolated muons with all muons in PFBRECO:

# replace isolated muons with all muons in PFBRECO
process.patMuonsPFlow.pfMuonSource = "pfMuonsPFlow" 

Now let's have a look at the muon isolation.

root
.L $CMSSW_RELEASE_BASE/src/CommonTools/ParticleFlow/test/Macros/rootlogon.C
loadFWLite()
TFile f("patTuple_PFBRECO.root")

Plot the relative, combined isolation computed in the PFBRECO sequence, used to select the PF muons that will make it to pat::Muons and apply dbeta correction.

Events.Draw("(selectedPatMuonsPFlow.chargedHadronIso() + selectedPatMuonsPFlow.photonIso() + selectedPatMuonsPFlow.neutralHadronIso()) / selectedPatMuonsPFlow.pt()>>h1")
Events.Draw("(selectedPatMuonsPFlow.chargedHadronIso() + max( 0, selectedPatMuonsPFlow.photonIso() + selectedPatMuonsPFlow.neutralHadronIso()-0.5*selectedPatMuonsPFlow.puChargedHadronIso()) ) / selectedPatMuonsPFlow.pt()>>h2","","same")
h2.SetLineColor(4)
h2.Draw()
h1.Draw("same")

Plot jet distribution.

Events.Draw("selectedPatJetsPFlow.pt()")

Question Question 7 l):

  • Did you see the little bump that appeared in the jet pT distribution?
  • Can you explain the shape of the muon isolation distribution?
  • Conclusion: which PFCandidates of type muon end up as pat::Muons? in pat::Jets?

Exercise 7 g): Investigate pile-up removal in PFBRECO

By default, PFBRECO starts by identifiying the charged particles coming from a pile-up vertex, and masks them out so that they are not used in the remaining processing sequence, for example when:

  • computing the particle-based isolation
  • clustering the jets
  • ...

In this exercise, we will create a second PFBRECO+PAT sequence, in which the pile-up identification and masking procedure is deactivated, so that all particles are used in the remaining processing sequence. Then, we will study the effect of the pile-up identification and masking.

cp patTuple_PFBRECO_cfg.py pileUp_PFBRECO_cfg.py

Edit pileUp_PFBRECO_cfg.py to:

  • add the new PFBRECO+PAT sequence
  • read a RelVal sample generated with pile-up
  • disable pile-up removal in this new sequence
  • relax the combined isolation cut for both sequences

# reading a pile-up Data sample:

process.source.fileNames = [ 
  '/store/data/Run2011B/DoubleMu/AOD/PromptReco-v1/000/180/072/0825E2B2-0C03-E111-BBB5-BCAEC518FF5F.root'
] 

# set runOnMC=False
usePFBRECO(process,runPFBRECO=True, jetAlgo=jetAlgo, runOnMC=False, postfix=postfix)

# adding the new PFBRECO sequence :

postfix2 = "PFlow2" 
usePFBRECO(process,runPFBRECO=True, jetAlgo=jetAlgo, runOnMC=False, postfix=postfix2)

process.p = cms.Path( 
getattr(process,"patPFBRECOSequence"+postfix) 
# second PFBRECO 
+ getattr(process,"patPFBRECOSequence"+postfix2) 
)

# disabling pile-up removal in the new PFBRECO+PAT sequence

getattr(process,"pfNoPileUp"+postfix2).enable = False

# relaxing the muon isolation in both sequences: 
getattr(process,"pfIsolatedMuons"+postfix).isolationCut = 99999. 
getattr(process,"pfIsolatedMuons"+postfix2).isolationCut = 99999.

Check your modifications:

edmConfigBrowser pileUp_PFBRECO_cfg.py

In particular, check that:

  • the new PFBRECO+PAT sequence is there
  • the pfNoPileUp module is configured correctly in each PFBRECO+PAT sequence
  • the pfIsolatedMuons combinedIsolationCut is relaxed in each PFBRECO+PAT sequence

If you feel confident, run:

cmsRun pileUp_PFBRECO_cfg.py

Question Question 7 m):

  • What distributions would you expect to change most dramatically?
  • In ROOT, investigate the effect of the pile-removal on all physics objects, by comparing the PFlow and PFlow2 collections.

Question Question 7 n):

  • modify your cfg to keep the collection of offlinePrimaryVertices, and re-run. what is the effect of the PFBRECO pile-up removal on events containing only one primary vertex?

ALERT! Note:

In case of problems don't hesitate to contact the SWGuidePAT#Support. Having successfully finished Exercise 7 you might want to proceed to Exercise 8 of the SWGuidePAT to learn more about how PAT supports collecting more information across objection collections, like the releation of jets to electrons directly in the jet object. For an overview you can go back to the WorkBookPATTutorial entry page.

Additional information

Review status

Reviewer/Editor and Date (copy from screen) Comments
RogerWolf - 17 March 2012 Added color coding -- we still need a general adaptatino to the Question and Exercise model here.

Responsible: SalRappoccio

Edit | Attach | Watch | Print version | History: r1 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r1 - 2012-06-25 - HeinerTholen
 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    CMSPublic All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2019 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback