JetVertexFraction: Selecting jets in pile-up events using jet-vertex association

Introduction

Warning, important This page is currently being updated and relocated to the jet calibration domain. References and information are correct but incomplete.

A method originally developed by the D0 collaboration [1] allows for the identification and selection of jets originating in the hard-scatter interaction through the use of tracking and vertexing information. By combining tracks and their primary vertices with calorimeter jets we define a discriminant, the Jet Vertex Fraction (or JVF) which measures the probability that a jet originated from a particular vertex. Jet selection based on this discriminant is shown to be insensitive to the contributions from simultaneous uncorrelated soft collisions that occur during pile-up.

Jet-vertex association (JVA) ATLAS Notes and documentation

Initial algorithm description in ATLAS Communications Note

A detailed description of the algorithm and preliminary testing using simulated data in ATHENA Release 12 can be found in the ATLAS communications note ATL-COM-PHYS-2008-008 [2], submitted 29 January 2008. The note be found in CDS at the following URL:

Updated JVA and jet-vertex fraction jet-energy scale corrections ATLAS Internal Note (currently under review)

Following extensive studies of the performance of the jet-vertex association algorithm and the clear need to improve on the efficiency obtained when simply cutting away jets with pile-up contributions, we released a more complete study of the algorithm using jet-vertex fraction jet energy scale (JES) corrections for pile-up. These studies are documented in the internal note (currently under review) here:

Performance of the algorithm

In the above mentioned studies, after using the JetVertexFraction to select jets with a high fraction of track energy originating the selected primary vertex, the jet multiplcity in a low luminosity environment (with an average of 2.3 minimum bias interactions per bunch crossing, corresponding to 10^{33} cm^{-2}sec^{-1}) is shown to be constant as a function of the number of reconstructed primary vertices in the event. This can be seen in the following plots (taken from [2])

jet multiplicity in ttbar events with pile-up jet multiplicity in J6 (di-jet) events with pile-up

Using the JetVertexFraction (JVF) ATHENA AlgTools

The algorithm has been implemented as an ATHENA AlgTool. Several public member methods are available in order to accomplish specific tasks. The most relevant of which being the ability to return a vector of doubles for each jet in the event which corresponds to the fraction of track energy matched to that jet, originating in each of the reconstructed primary vertices in the event. The vertex and track collections to use for the matching must be passed to the tool in the user's code. This facilitates the option of modifying or creating a new vertex collection in the user algorithm (say, by refitting tracks) and then passing this new set of primary vertex candidates to the JVF tool.

One difficulty that needs mentioning is the existence of "split vertices," an artifact of the ATLAS vertexing software. Currently, a large number of vertices are found from outlier tracks and are considered as plausible primary vertex candidates, despite being, in some cases, within very close distances of a very large track multiplicity vertex. These split vertices will therefor bias the jet-selection when tracks used in the fit are also matched to jets in the event.

I have written a vertex merging method that attempts to alleviate this predicament, but that is not included in the example algorithm.

Documentation

Description

The package contains 3 components right now

  1. JetTrackVertexHelperTool : AlgTool
    1. This tool has some basic helper methods such as
      1. void printVxInfo(const Trk::VxCandidate* vtx)
      2. double getTrackChi2NDF(const Rec::TrackParticle *trackParticle)
      3. double getTrackChi2NDF(const Rec::TrackParticle *trackParticle)
      4. vector getJetTracks(ParticleJet *jet, double deltaR)
      5. etc.... (take a look at the header wink )
    2. Several of these helper methods are used by the JetVertexFraction tool, but none that require configuration at the job option level. That means that the user can take a utilize the Helper tool and configure it in any way he or she likes.
  2. JetVertexFractionTool : AlgTool
    1. This tool's primary function is to calculate the fraction of track energy originating in each primary vertex candidate in the event through the public member method std::vector getJVF(ParticleJet *jet)
    2. Other very useful methods are:
      1. vector getJVFJetTracks(ParticleJet *jet) which returns the list of tracks used in the JVF calculation
      2. vector getJVFJetVertices(ParticleJet *jet, double jvfCut) which returns all vertices contributing a minimum fraction jvfCut to the jet energy of jet jet
  3. MyJVFExample : CBNT_AthenaAwareBase
    1. This is a simple CBNT/AANT-style algorithm that implments several of the functionalities of the above mentioned tools.
    2. It is hoped that the examples given here will provide enough basic understanding of how the tools are supposed to work so that the user can take and implement these tools in their own analysis code.

Check out and compile the package

The code currently resides in the SLAC CVS repository. This is readable by all of ATLAS, but not writable. Here's how you can grab the code:

cmt co -r JetTrackTools-00-00-01 -o groups/slac JetTrackTools
rm JetTrackTools/src/*Corrector*
cd JetTrackTools/cmt/
cmt config
source setup.sh
make
cd ..
mkdir run
cd run

If you notice, I suggest that you delete all the source files named Corrector...this is simply because they are skeleton code and will not compile if you try.

Job Option setup to run the example MyJVFExample

Located in JetTrackTools/share is a jobOption file MyJVFExample_jobOptions.py You'll need to change input dataset and output Ntuple names

ServiceMgr.EventSelector.InputCollections = PATH-TO-YOUR-PILEUP-SAMPLE
OutputNTUP  = PATH-TO-YOUR-OUTPUT-NTUPLE

There are then several job options that you can specify specific to this example algorithm

  • Jet, vertex and track collections

MyJVFExample.ParticleJetContainer       = "Cone4H1TowerParticleJets"
MyJVFExample.TrackParticleContainerName = "TrackParticleCandidate"
MyJVFExample.PrimaryVertexContainer     = "VxPrimaryCandidate"

  • Whether you want to print out track and vertex information to your log file

MyJVFExample.PrintTrkAndVtxInfo = False

  • The jet ET and Eta cuts

MyJVFExample.jetEtMin  = 10*GeV
MyJVFExample.jetEtMax  = 25000.0*GeV
MyJVFExample.jetEtaMin = 0.0
MyJVFExample.jetEtaMax = 2.0

  • The delta R (eta,phi) requirement for matching a track to a jet...this is just for general track-matching purposes. You specifically set the delta R cut for the JVF Tool below.

MyJVFExample.DeltaRMatchCut  = 0.4

  • The minimum fraction of track energy originating in the selected primary vertex required. This is used because the example cre

MyJVFExample.JetVertexFractionCut = 0.75

Configuring the JetTrackVertexHelperTool and JetVertexFractionTool

In the job options file we need to grab the helper from the tool service and then specify the parameters (defaults are also given in the .cxx file)

MyOutputLevel = INFO

#-------------------------------
# Jet,Track,Vertex Helper Tool
#-------------------------------
ToolSvc = Service( "ToolSvc" )
JTVHelperTool = Algorithm( 'ToolSvc.JetTrackVertexHelperTool' )
JTVHelperTool.OutputLevel   = MyOutputLevel

#-------------------------------
# JetVertexFraction (JVF) Tool
#-------------------------------
ToolSvc = Service( "ToolSvc" )
JVFTool = Algorithm( 'ToolSvc.JetVertexFractionTool' )
JVFTool.OutputLevel    = MyOutputLevel

JVFTool.DeltaRMatchCut = 0.4         # Delta R between track and jet
JVFTool.UseSecVtx      = True        # Use tracks originating in SV's?
JVFTool.UsePileUpVtx   = True        # Use tracks originating in Pileup Vtx's?
JVFTool.UseConvVtx     = True        # Use tracks originating in conv. Vtx's? !!! NOT IN R12
JVFTool.UseV0Vtx       = True        # Use tracks originating in V0 vtx's?    !!! NOT IN R12
JVFTool.UseKinkVtx     = True        # Use tracks originating in kink Vtx's?  !!! NOT IN R12

# Track selection for tracks in JVF calculation
JVFTool.trkZ0cut       = 200.*mm
JVFTool.trkD0sigcut    = 100.        # R13: d0 errors make no sense (some at 400 nm!) --> can't use significance
JVFTool.trkD0cut       = 1.*mm
JVFTool.trkPtMin       = 0.4*GeV
JVFTool.trkPtMax       = 5000.*GeV
JVFTool.trkEtaMin      = 0.0
JVFTool.trkEtaMax      = 2.5
JVFTool.trkChi2ndfMax  = 3.0
JVFTool.trkPixHitsMin  = 1
JVFTool.trkPixHitsMax  = 5
JVFTool.trkSCTHitsMin  = 5
JVFTool.trkSCTHitsMax  = 20
JVFTool.trkTRTHitsMin  = 0
JVFTool.trkTRTHitsMax  = 40
JVFTool.trkSiHitsMin   = 7

Run the example Algorithm: MyJVFExample

Assuming that you are in the JetTrackTools/run directory, you can run with

athena.py ../share/MyJVFExample_jobOptions.py >& logfile.log

This will run over the dataset that you specify in the job options and produce the output root file at the location that you specify. For example, when I run the algorithm I obtain

[yakut01] 13.0.30 > root -l ~/scratchspace/example/MyJVFExample_TTPileup_R13_private.1000.Evt.root 
root [0] Attaching file /u/at/fizisist/scratchspace/example/MyJVFExample_TTPileup_R13_private.1000.Evt.root as _file0...
root [1] .ls
TFile**         /u/at/fizisist/scratchspace/example/MyJVFExample_TTPileup_R13_private.1000.Evt.root
 TFile*         /u/at/fizisist/scratchspace/example/MyJVFExample_TTPileup_R13_private.1000.Evt.root
  KEY: AttributeListLayout      Schema;1
  KEY: TDirectory       JVFPlots;1      JVFPlots
  KEY: TTree    CollectionTree;1        CollectionTree
  KEY: TProfile JetMult_pfx;1   Total jet multiplicity
  KEY: TProfile JetMultJVF_pfx;1        Selected jet multiplicity

And the following profile plots of average jet multiplicity versus reconstructed vertex multitplicity are found

root [2] TProfile *allJets = (TProfile*)gDirectory->Get("JetMult_pfx")
root [3] TProfile *selectedJets = (TProfile*)gDirectory->Get("JetMultJVF_pfx")
root [4] allJets->Draw()
<TCanvas::MakeDefCanvas>: created default TCanvas with name c1
root [5] selectedJets->Draw("same")

References

  • [1] DŲ Collaboration, Measurement of the ppbar to ttbar production cross section at sqrt(s)=1.96 TeV in the fully hadronic decay channel, arXiv:hep-ex/0612040v1
  • [2] Miller, DW, Schwartzman, A and Su, D. Jet-Vertex Association Algorithm, ATL-COM-PHYS-2008-008, http://cdsweb.cern.ch/record/1082880

-- DavidMiller - 14 Feb 2008

Topic attachments
I Attachment History Action Size Date Who Comment
PNGpng J6Pileup_jetVsvtxMultCPF.png r1 manage 14.7 K 2008-02-14 - 02:18 DavidMiller J6 jet multiplicity in events with pile-up
PNGpng TTPileup_jetVsvtxMultCPF.png r1 manage 14.8 K 2008-02-14 - 02:18 DavidMiller ttbar jet multiplicity in events with pile-up
Edit | Attach | Watch | Print version | History: r9 < r8 < r7 < r6 < r5 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r9 - 2018-02-26 - FassiFarida
 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    Main 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