B Jet High Level Trigger

Complete: 4

Introduction

The HLT trigger menus in 2010 include two types of b-tagging paths:

  • BTagMu_JetNNN, BTagMu_DiJetNNN and BTagMu_DiJetNNN_Mu5 : selecting events with muons close to jets and providing a calibration sample for the measurement of the b-tag efficiency
  • BTagIP_JetNNN : events with at least one b-tagged jet, based on impact parameters (switched off from 2E31 HLT menu, run 146428 starting 22 Sep 2010 onwards)

BTagIP_JetNNN and BTagMu_JetNNN b-tag paths are enabled since May 2010. The evolution of the HLT b-tag paths with the HLT menus in 2010 are documented in *this talk.*

Contact

Feel free to contact the b-tag trigger contact Roberval Walsh if you have any queries.

Triggers for 2011

1E33 Development page

latest version of the 5E32 menu

For more up to date information visit the TriggerReviews 2010-2011 Twiki

This section includes the proposed/approved paths involving b-tags @HLT.

BTV Trigger Talk during April Physics/Trigger Jamboree

Present PAG triggers in 2011 using BTagIP at HLT

BTagMu path

SoftMuon based b-tag trigger paths aka BTagMu paths for the b-tag calibration triggers:

  • Proposed paths for 2011 running are available in this TALK Agiven during the First Trigger Review.

  • PU studies for the proposed paths in "high lumi" scenarios can be found in this TALK given during the Second Trigger Review.

BTagIP path

As previously mentioned IP based paths were switched OFF in 2010 from 2E31 menu onwards.

  • QuadJet + IP b-tag based path for ttbar hadronic final state implementation is presented this TALK given during the First Trigger Review

Fast Primary Vertex at HLT

The Fast Primary Vertex (FastPV) algorithm, developed by A. Rizzi and J. Bernardini (see Andrea's talk in the TSG here for algorithm description), has been implemented in the HLT software. The main advantage of this algorithm is the reduced HLT CPU time usage while keeping the vertex reconstruction and b-tagging efficiencies compared to the usual global pixel tracking/vertexing.

Users willing to use FastPV can find examples in ConfDB, /users/rwalsh/dev/CMSSW_5_2_1/FastPrimaryVertex/V13. In that configuration there are two paths that simply reconstruct pixel vertices with FastPV. The two paths differ only by the use of 3D or 1D vertex. The users should use the one that better fulfils their needs.

Basically, two sequences in the example paths are needed.

One needs the selected jets and the pixel vertex collections that are used as input to b-tagging. Those are called:

  • hltSelectorJets20L1FastJet: Contains up to four leading jets (CaloJets L1FastJet corrected) with ET>20 GeV. That's for developers who uses the L1FastJet corrected caloJets. If another type of jets, such as PFlow jets, is preferred for the b-tagging or other applications, the developer has to provide the appropriate collection.
  • hltFastPixelVertices(3D): Contains the pixel vertices in 1D (3D).

ALERT! Those developers who need to perform further filtering of the pixel vertices, please do so outside the sequence. Filtering is pretty much particular to each path.

Another example of a full implementation with b-tagging sequences can be found in ConfDB /users/rwalsh/dev/CMSSW_5_2_1/bbPhiFastPV/V10. The paths therein are the all-hadron MSSM H->bb. One can use the "diff" tool in ConfDB with respect to V9 of the same configuration to see the modifications.

If you need help please do not hesitate to contact the BTag Trigger contact either via HLT Development HN (hn-cms-hlt@cernNOSPAMPLEASE.ch).

b-jet reconstruction at HLT

Partial reconstruction @ HLT

Documentation

The HLT algorithms and performance are described in CMS NOTE-2006/030 and update in CERN/LHCC 2007-021.

This document is old but the basic idea of BTagMu and BTagIP paths still remains the same.

General Recommendations

  • TrackCounting in HLT should always be looser than offline selection
    Example
    TCHE (2nd track) @HLT when using TCHP (3rd track) Offline
    Tune the selection cuts/discriminator cuts at L2.5 and L3
  • Could even make use of Track Counting based on “Single Track” @ HLT (depends on signal MC efficiency vs rate reduction)
  • No secondary vertex @HLT, pixel tracks not precise enough. Timing and loss of signal efficiency is an issue using SSV at HLT b-tag efficiency is ~60% for SSV High Eff Offline


  • Its NOT recommended to cut on absolute value of the discriminators L2.5/L3.
  • Its NOT recommended to cut on any (L2.5/L3 TCHE/SingleTrack TC) discriminator at 0 or below (or too nearby).
  • The Track Counting (TC) algorithms must be used at meaningful working points. So if the cut is below ~2-3, it means one can use the TC with one track less.
  • Offline Working Points are available at: BTagPerformanceOP


Regarding recommended checks for the usage of Online Beam Spot by the b-tag IP path at HLT

CMSSW Software and OpenHLT

CMSSW Producers for JetTrackAssociators, TagInfos and JetTags Computers etc used at HLT are same as the ones used in Offline Reconstruction. HLT specific trigger code is available in HLTrigger/btau Contains HLT filter HLTJetTag to filter events based on discriminator cut and also helper function GetJetsFromHLTobject to access the jets from the TriggerFilterObjectWithRefs

OpenHLT is the official tool for emulating new triggers and also for rate estimates. The link below describes available b-jet specific information in the OpenHLT ntuples.

OpenHLT b-jet information

By default Track Counting High Efficiency aka TCHE (based on 3D IP Significance of 2nd track) is available at HLT. If one wants to use "Single Track" TC then following ESProducer needs to be added in ConfDB:

process.hltESPTrackCounting3D1st = cms.ESProducer( "TrackCountingESProducer",
  appendToDataLabel = cms.string( "" ),
  nthTrack = cms.int32( 1 ),
  impactParameterType = cms.int32( 0 ),
  deltaR = cms.double( -1.0 ),
  maximumDecayLength = cms.double( 5.0 ),
  maximumDistanceToJetAxis = cms.double( 0.07 ),
  trackQualityClass = cms.string( "any" )
)

Note : nthTrack = cms.int32( 1 ) for "Single Track" TC
nthTrack = cms.int32( 2 ) for TCHE

Implementation of the 3D PixelVertex reconstruction

  • By default hltOnlineBeamSpot in transverse plane and 1DPixelVertices in Z are used as reference.
    In order to include the reconstruction of the 3D PixelVertices, the following lines have to be added in the configuration file:
       hltPixelVertices3D = cms.EDProducer("PrimaryVertexProducer",
           PVSelParameters = cms.PSet(
               maxDistanceToBeam = cms.double(2), 
           ),
           verbose = cms.untracked.bool(False),
           algorithm = cms.string('AdaptiveVertexFitter'), 
           useBeamConstraint = cms.bool(False),
           minNdof  = cms.double(0.0),               
           TkFilterParameters = cms.PSet(
               algorithm=cms.string('filter'),
               maxNormalizedChi2 = cms.double(100.0),
               maxD0Significance = cms.double(100.0), 
               minPixelLayersWithHits = cms.int32(3),   
               minSiliconLayersWithHits = cms.int32(3), 
               minPt = cms.double(0.0),
               trackQuality = cms.string("any")
           ),
           beamSpotLabel = cms.InputTag("hltOnlineBeamSpot"),
           TrackLabel = cms.InputTag("hltPixelTracks"),
           TkClusParameters = cms.PSet(
               algorithm   = cms.string("gap"),
               TkGapClusParameters = cms.PSet(
                   zSeparation = cms.double(0.1)        
               )
           )  
       )
    

Note: The minPt parameter (Pt threshold of hltPixelTracks selected for the primary vertex fit) has to be tuned within your concrete trigger path. The information needed to set the working point for the PrimaryVertexProducer is available Carlotta's talk on 25th March 2011 and Carlotta's talk on 6th April 2011. These talks include a summary of the 3D vertex reconstruction performance (vertex finding efficiency, fake rate, resolution) as a function of the needed CPU timing, compared to the standard 1D algorithm.

  • You can now define a new Sequence including the hltPixelVertices3D:
       HLTRecopixelvertexing3DSequence = cms.Sequence( hltPixelTracks + hltPixelVertices3D)   
    and replace the old HLTRecopixelvertexingSequence with the new HLTRecopixelvertexing3DSequence in your trigger path.
  • The configuration fragment for the BTagInfo producers (TrackIPProducer) for both L25 and L3 has to be changed to take as input to the IP calculation the new hltPixelVertices3D :
      primaryVertex = cms.InputTag("hltPixelVertices3D"),   
  • Also in hltBLifetimeRegionalPixelSeedGenerator replace
      InputTag vertexSrc = hltPixelVertices   
    with
      InputTag vertexSrc = hltPixelVertices3D   
  • Example ConfDB implementation can be found at: /users/jyothsna/BTagIPExamples/HLT3DPixelVertexExample/V1
    There is catch here: for now manually edit python dump of your HLT menu. Change all the untracked PSet in hltPixelVertices3D to PSet Note: Proper solution in ConfDB will be provided soon. But for now this should let the users develop the paths making use of 3D PV.

Links to the talks given in different meetings


Talks on Online Beam Spot

Useful Links

Pretty Old instructions

If you are interested in looking at the old instructions pre 2007 era then

The b-tagged multi-jet HLT trigger is described in CERN/LHCC-2007-021. It uses lower jet Et thresholds than the standard multi-jet HLT trigger, but requires one of the jets to be b-tagged.

There is also a b --> mu based Trigger. This is described in the same note.

To use the b-tagged multi-jet HLT in CMSSW, get the latest HLT software as described here. (You can probably skip corrections to packages specific to non-b triggers). The b-HLT is in HLTrigger/btau/ .

To run the b-lifetime HLT (including the reconstruction it needs), use HLTrigger/btau/test/hltLifetimeBTag.cfg. To run the b-->mu HLT (including the reconstruction it needs), use hltSoftMuonBTag.cfg. (These should be already run in RECO datasets generated with 1.6.0 or later).

The program HLTrigger/btau/test/stubs/bLifetimeHLTanal.cfg illustrates how to look at the trigger results (for the b-lifetime HLT). It makes histograms of trigger pass rates and of jet Et spectra etc. You can then calculate the trigger rates and produce the plots of trigger turn-on curves shown in CERN/LHCC-2007-021, by running the following ROOT Macros (available in the same stubs directory) on the output:

Start an interactive ROOT session and type:

1) .L bLifetimeHLTComputeRates.C++ 2) bLifetimeHLTComputeRates()

This integates the histograms, such as jet Et spectra, and so converts them to turn-on curves for the triggers. If running on QCD, it also sums the different pt_hat datasets, but this isnt needed for the tt sample.

3) .L bLifetimeHLTPlotsRates.C++ 4) bLifeetimeHLTPlotRates()

This makes pretty eps files of the figures in the note.

The software has been checked with 1.6.0.

Contacts: A.Bocci, I.Tomalin, A.Avetisyan, M.Narain

Review Status

Reviewer/Editor and Date (copy from screen) Comments
JyothsnaK - 25-Oct-2010 updated info on HLT b-tag paths
Main.tomalini - 11 Sept 2007 updated to 1.6.0 (Ian Tomalin)
JennyWilliams - 07 Feb 2007 editing to standardize for SWGuide
Main.tomalini - 11 Jan 2007 page created (Ian Tomalin)

Responsible: Main.tomalini
Last reviewed by: Reviewer

Edit | Attach | Watch | Print version | History: r47 < r46 < r45 < r44 < r43 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r47 - 2012-04-02 - RobervalWalsh



 
    • 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