7.9 B-Tagging

Goals of this page

This page introduces the principal algorithms used to tag b-jets and will help you decide which one will be most suitable for your physics analysis. It then explains how to access the most commonly used b tag information.

Please also note that from version 1.7.0 onwards the bTagging data formats have been frozen. Whatever you read on 1.7.X you can safely applied to any 2.X.Y and 3.X.Y versions (at least for what concerns data formats).

Expert users may also wish to consult the b tag chapter of the CMSSW Offline Guide for more detailed information, such as how to modify and rerun the b tagging algorithms.

Contents

• b Tag Algorithms - which one to use ?
• b Tag AOD/RECO data
• b Tag Analysis with bar ROOT, FWLite or EDAnalyzers
  • b Tag Analysis with bare ROOT
  • b Tag Analysis with CMSSW Framework Light (fwLite)
  • b Tag Analysis with a CMSSW EDAnalyzer
    • How to determine the True Flavour of a Jet
    • How to make plots of b tag performance
• Advanced topics
  • How to run a new tagger
  • How to run on a different jet collection
• Further Information
• Review status

b Tag Algorithms - which one to use ?

Several b tag algorithms have been implemented in CMSSW. Some exploit the long B hadron lifetime, others its semi-leptonic decay mode and others use kinematic variables related to the high B hadron mass and hard b fragmentation function.

All begin by associating good quality tracks with jets. By default, b tag algorithms are only run on iterativeCone5CMS.CaloJets (i.e. uncalibrated, iterative-cone jets produced with Delta(R) = 0.5) up to CMSSW_2_X_Y, and on AntiKt05 starting from CMSSW_3_X_Y. Instructions on how to tag alternative jet collections are given below.

In CMSSW, all the algorithms produce a b tag "discriminator" for each jet, on which one can cut more or less tightly, in order to distinguish b-jets from non-b jets. Although the definition of the discriminator varies between algorithms, it is always true that b-jets have more positive values of the discriminator. This page will help you choose a sensible cut value for the discriminator.

• "Track Counting" algorithm: More... Close This is a very simple tag, exploiting the long lifetime of B hadrons. It calculates the signed impact parameter significance of all good tracks, and orders them by decreasing significance. Its b tag discriminator is defined as the significance of the N'th track. It comes in two variations for N = 2 (high efficiency) or N = 3 (high purity).
• "Jet Probability" algorithm: More... Close This is a more sophisticated algorithm, also exploiting the long lifetime of B hadrons. Its b tag discriminator is equal to the negative logarithm of the confidence level that all the tracks in the jet are consistent with originating from the primary vertex. This confidence level is calculated from the signed impact parameter significances of all good tracks. It reads the resolution function on these from a database (DB). Indeed, we have two versions of this tagger: JetProbabilityBJetTags and JetBProbabilityBJetTags - the latter uses only the four most displaced tracks, matching the typical reconstructed multiplicity of a B decay vertex.
• "Soft Muon" and "Soft Electron" algorithms: More... Close These two algorithms tag b jets by searching for the lepton from a semi-leptonic B decay, which typically has a large Pt_rel with respect to the jet axis. Their b tag discriminators are the output of neural nets based on the leptons Pt_rel, impact parameter significance and a few other variables. For each of these taggers, we want to have a simple one (cutting basically only on the presence and pT of the lepton), and a complex one using also jet quantities to compute a MVA analysis. This is already the case for Muons; Electron taggers need refinement and are not really usable up to 2.1.X.
• "Simple Secondary Vertex" algorithms: More... Close These class of algorithms reconstructs the B decay vertex using an adaptive vertex finder, and then uses variables related to it, such as decay length significance to calculate its b tag discriminator. It has been found to be more robust to Tracker misalignment than the other lifetime-based tags. CMSSW releases <= 35X contain one version of the algorithm (simpleSecondaryVertexBJetTags). Starting from 36X two versions will be provided: simpleSecondaryVertexHighEffBJetTags (equivalent to the previous version) and simpleSecondaryVertexHighPurBJetTags (with increased purity due to a cut on the track multiplicity at the secondary vertex)
• "Combined Secondary Vertex" algorithm: More... Close This sophisticated and complex tag exploits all known variables, which can distinguish b from non-b jets. Its goal is to provide optimal b tag performance, by combining information about impact parameter significance, the secondary vertex and jet kinematics. (Currently lepton information is not included). . The variables are combined using a likelihood ratio technique to compute the b tag discriminator. A variant of this tagger combines the variables using the Multivariant Analysis (MVA) tool.

In CMSSW 1.5 - 1.6, the "Jet Probability" algorithm gives best performance and is consequently recommended for most physics analyses. In older versions of CMSSW, this is not available, and you should instead use the simpler, but fairly effective "Track Counting" algorithm. The "Soft Lepton" algorithms have several times lower efficiency due to the low B semi-leptonic branching ratio, but can sometimes be useful, particularly for early data taking or for measuring b tag performance with data. The "Combined Secondary Vertex" algorithm should ultimately give better performance than the Jet Probability algorithm, but only becomes competitive with it in CMSSW 1.7, and becomes the most powerful algorithm since CMSSW_2_X_Y (but beware it will be the most difficult to calibrate on data).

So the advice is

• for initial analysis, stick to the TrackCounting;
• when experience is gained on data, you can move to algorithms more complicated and performing.

b Tag AOD/RECO Data

The full data format is described here in the CMSSW Offline Guide. However, this section gives you an overview.

Each b tag algorithm produces a collection of JetTag and various kinds of TagInfo (Each collection has one entry for each jet, ordered as in the original jet collection). For most physics analyses, you will only need to access the JetTag object:

This gives the b tag discriminator value and a references (link) to the jet. The JetTag collections are labelled by the b tag algorithm that produced them. In CMSSW 1.7, the most important of these labels are:

• Track counting tag with N = 3: trackCountingHighPurBJetTags
• Track counting tag with N = 2: trackCountingHighEffBJetTags
• Jet probability tag: jetProbabilityBJetTags
• Soft electron tag: softElectronBJetTags
• Soft muon tag: softMuonBJetTags
• Soft muon tag, not using muon impact parameter significance: softMuonNoIPBJetTags
• Simple secondary vertex b tag: simpleSecondaryVertexBJetTags
• Combined SV b tag using likelihood ratios: combinedSVBJetTags
• Combined SV b tag using MVA: combinedSVMVABJetTags

For a full list of these labels in any CMSSW version, see the file RecoBTag/Configuration/python/RecoBTag_EventContent.cff .

The TagInfo contains the variables, such as track impact parameter significance, from which the b tag discriminator was calculated. It also gives you the jet and the tracks associated with it. There are several different types of TagInfo object, for the various b tag algorithms. The TrackIPTagInfo is shared by the Track Counting, Jet Probability and CombinedSV tags. Sophisticated b tags, such as the CombinedSV tag can use more than one TagInfo. (It also uses SecondaryVertexTagInfo).

The b tag algorithms also rely on the association of tracks with jets. This information is stored in JetTracksAssociation. However, it can be accessed by the JetTag or TagInfo classes, so you should not need to worry about this.

The above CMSSW 1.7 documentation is kept here and is valid for every later release (including CMSSW_2_X_Y and CMSSW_3_X_Y).

b Tag Analysis with bare ROOT, FWLite or EDAnalyzers

BEWARE - THIS DOES DOT WORK ANYMORE WITH CMSSW_3_X_Y; USE FWLITE INSTEAD

This section describes how to analyze b tag information with bare ROOT, FWLite and EDAnalyzers. The first two can be useful for a quick look at the data, whereas the latter is recommended for serious analysis. To follow the examples here, please find some t-tbar events with DBS. (For CMSSW 1.6, /store/mc/2007/10/20/RelVal-RelValTTbar-1192895175 /0000/00C41641-2A81-DC11-B6EA-0019DB29C620.root is available at CERN).

b Tag Analysis with bare ROOT

To quickly look at the b-tag information inside a CMSSW dataset, it can be convenient to simply look at the data via bare ROOT. However, you will only be able to look at simple data members (e.g. float, int) inside classes, as illustrated below. Also be warned that the TBrowser interface can be very slow when run on a virtual machine. This method may be suited best for when one has local access to the relevant files.

In lxplus, access an example Run3 PYTHIA simulation data file via the command:

root -l file:/afs/cern.ch/cms/Tutorials/workbook_twiki2021/MinBias_pythia8_14TeV_100events.root

Open a browser window via

TBrowser b;

and then navigate in the TBrowser to the Event directory, where you can find the b-tag information. In this example, we will look at the b-tag recoJetedmRefToBaseProdTofloatsAssociationVector_pfJetBProbabilityBJetTags_RECO. In general, names have the form 'C++ namespace' 'class name'_'label'_RECO.

Double-clicking on recoJetedmRefToBaseProdTofloatsAssociationVector_pfJetBProbabilityBJetTags_RECO and then recoJetedmRefToBaseProdTofloatsAssociationVector_pfJetBProbabilityBJetTags_RECO.obj lets one see the C++ data members of the JetTag object. Finally, double-clicking on recoJetedmRefToBaseProdTofloatsAssociationVector_pfJetBProbabilityBJetTags_RECO.obj.data shows the histogram of the b-tag discriminator value, as shown in the screen capture below.

The above CMSSW 12.0 documentation is kept here.

b Tag Analysis with CMSSW Framework Light (fwLite)

This is convenient for quickly looking at the data, with the bonus of being able to use the public member functions of any class stored in the event. You should first set up your CMSSW environment from inside your project area and start ROOT (we work in this example with CMSSW_12_0_0 and a small Run3 PYTHIA8 sample).

eval 'scramv1 runtime -csh'
root

then make the CMSSW FWLite libraries available and open the dataset:

gSystem->Load("libFWCoreFWLite.so");
FWLiteEnabler::enable();

Define the data file:

TFile *f = TFile::Open("file:/afs/cern.ch/cms/Tutorials/workbook_twiki2021/MinBias_pythia8_14TeV_100events.root");

We can now set some aliases for b-tag objects (if you don't know the exact name of b-tag object, check using TBrowser). While defining aliases is not necessary, it does make the subsequent analysis much simpler:

Events->SetAlias("bmu","recoJetedmRefToBaseProdTofloatsAssociationVector_pfJetBProbabilityBJetTags_RECO.obj");

Functionality is somewhat limited by the fact that an association map is involved, you can, for example, get the number of b-tagged jets as

Events->Draw("bmu.size()");

Since one will likely be running this command on a remote machine where ROOT's GUI may be slow, it may be convenient to simply save the figure (perhaps as a pdf) and examine it offline. This can be done by the command:

c1->SaveAs("path/to/myWorkArea/nameOfFigure.pdf");

The above CMSSW 12.0 documentation is kept here.

b Tag Analysis with a CMSSW EDAnalyzer

Most physics analysis will use this method, as it is the most general and flexible way to access and save event information. One should start by learning how to create a generic EDAnalyzer and configuration files, as described here in the workbook.

In summary, to access b-tag information in each event, one can edit your EDAnalyzer code in the following ways. Add the following header file at the beginning of the code:

#include "DataFormats/BTauReco/interface/JetTag.h"

Add the following line below the include statements:

using reco::JetTagCollection;

In the EDAnalyzer class definition section, define a token to identify the b-tagging discriminator you want to study:

edm::EDGetTokenT<JetTagCollection> bTagToken_;

Finally, we access the b-tag information by adding the following lines in the EDAnalyzer::analyze() portion of the code:

// Get b-tag information
edm::Handle<JetTagCollection> bTagHandle = iEvent.getHandle(bTagToken_);
const reco::JetTagCollection &bTags = *(bTagHandle.product());

// Loop over jets and study b-tag info
for(unsigned int i = 0; i != bTags.size(); i++){
     printf("[bTagInfo] (pt, eta, phi) jet = %7.2f %6.3f %6.3f | 
                b-tag descriminator = %6.3f \n",
                bTags[i].first->pt(), bTags[i].first->eta(),
                bTags[i].first->phi(), bTags[i].second() ) ;
}

Next, we need to add the name of the b-tag input tag to the configuration file. This is done through the variable bTags (as defined in the above portion of the code). Add the following line to the configuration code:

bTags = cms.untracked.InputTag('myChosenBTag')

where myChosenBTag can be the module name of any b-tag discriminator one wants to analyze. Some examples include pfCombinedSecondaryVertexV2BJetTags, pfJetProbabilityBJetTags, softPFMuonBJetTags, and more. You can find all of the possible tags in a given data file by exploring the output of the command

edmDumpEventContent /path/to/mySourceDataFile.root

Next, we need to edit the Build.xml file associated with the EDAnalyzer. Add the line

<user name=DataFormats/BTauReco>

The output of your EDAnalyzer should look like this :

show hide

04-Feb-2022 22:26:01 CET  Initiating request to open file file:/afs/cern.ch/cms/Tutorials/workbook_twiki2021/MinBias_pythia8_14TeV_100events.root
04-Feb-2022 22:26:07 CET  Successfully opened file file:/afs/cern.ch/cms/Tutorials/workbook_twiki2021/MinBias_pythia8_14TeV_100events.root
Begin processing the 1st record. Run 1, Event 1, LumiSection 1 on stream 0 at 04-Feb-2022 22:26:22.670 CET

...

Begin processing the 34th record. Run 1, Event 32, LumiSection 1 on stream 0 at 04-Feb-2022 22:26:24.932 CET
analyzing event run: 1 lumi: 1 event: 32
[bTagInfo] (pt, eta, phi) jet =   51.85  0.323  2.104 | b-tag descriminator =  0.130 
[bTagInfo] (pt, eta, phi) jet =   43.04 -0.775 -1.651 | b-tag descriminator =  0.080 
[bTagInfo] (pt, eta, phi) jet =   26.93  0.123 -1.657 | b-tag descriminator =  0.250 
[bTagInfo] (pt, eta, phi) jet =   21.11 -1.077  1.221 | b-tag descriminator =  0.361 

...

Begin processing the 99th record. Run 1, Event 99, LumiSection 1 on stream 0 at 04-Feb-2022 22:26:26.543 CET
analyzing event run: 1 lumi: 1 event: 99
Begin processing the 100th record. Run 1, Event 95, LumiSection 1 on stream 0 at 04-Feb-2022 22:26:26.548 CET
analyzing event run: 1 lumi: 1 event: 95
[bTagInfo] (pt, eta, phi) jet =   23.35 -0.934 -0.067 | b-tag descriminator =  0.362 
[bTagInfo] (pt, eta, phi) jet =   21.11 -0.585 -0.919 | b-tag descriminator =  0.144 

The above CMSSW 12.0 and beyond documentation is kept here.

How to Determine the True Flavour of a Jet.

Detailed information on jet-flavour identification can be found here. In this section, we will give a brief outline on how to include jet-flavour information in one's EDAnalyzer.

There are many ways to define the flavour of a reconstructed jet. Jet flavour is determined by re-clustering the jet constituents with selected hadrons and partons. For each reconstructed jet, there is a JetMatchedPartonCollection (defined here). This is a data format where a MatchedPartons object (defined here) is associated to each jet. The result is that each jet is associated with five gen-level partons:

• the heaviest parton in the jet cone
• the nearest status=2 parton (no originating from an initial parton)
• the nearest status=3 parton (originating from primary physics process about the jet cone)
• the "physics definition" parton (legacy)
• the "algorithmic definition" parton (legacy)

Each of these partons assign a flavor to the jet. If one wishes to drop the associated MatchedPartons gen information (for instance, to save space), the jet-flavour information is still accessible through the JetFlavorMatchingCollection (defined here), wherein each jet is associated with a parton four-momentum (via LorentzVector) and jet flavour (via parton PDG ID code).

Next, we will outline how to implement the above information in an EDAnalyzer. First, we need to add the following process commands to our python configuration file:

process.myPartons = cms.EDProducer("PartonSelector",
              src = cms.InputTag("genParticles"),
              withLeptons = cms.bool(False)
)

process.flavourByRef = cms.EDProducer("JetPartonMatcher",
              jets = cms.InputTag("ak4PFJets"),
              coneSizeToAssociate = cms.double(0.4),
              partons = cms.InputTag("myPartons")
)

process.flavourByVal = cms.EDProducer("JetFlavourIdentifier",
              srcByReference = cms.InputTag("flavourByRef"),
              physicsDefinition = cms.bool(False)
)

Now add the following to the process.demo part of the configuration file:

srcSelectedPartons = cms.InputTag("myPartons"),
srcByReference = cms.InputTag("flavourByRef"),
srcByValue = cms.InputTag("flavourByVal"),
jetPtMin = cms.double(20.0),
jetEtaMin = cms.double(-1.6),
jetEtaMax = cms.double(1.6)

This will setup the gen-parton and jet-flavour tokens to input into the analyzer. Notice that we also define some jet kinematic cuts on p_T and η.

We will now edit our EDAnalyzer code to retrieve and print out the reconstructed jet flavour. First, define new variables and tokens in the data declaration portion of the code:

double jetPtMin_;
double jetEtaMin_;
double jetEtaMax_;

edm::EDGetTokenT<reco::JetMatchedPartonsCollection> sourceByReferToken_;
edm::EDGetTokenT<reco::JetFlavourMatchingCollection> sourceByValueToken_;
edm::Handle<reco::JetMatchedPartonsCollection> theTagByRef;
edm::Handle<reco::JetFlavourMatchingCollection> theTagByValue;

Next, in the constructor portion of the EDAnalyzer code, retrieve the tokens and variables from the configuration file via:

jetPtMin_(iConfig.getParameter<double>("jetPtMin")),
jetEtaMin_(iConfig.getParameter<double>("jetEtaMin")),
jetEtaMax_(iConfig.getParameter<double>("jetEtaMax")),
sourceByReferToken_(consumes<reco::JetMatchedPartonsCollection>(iConfig.getParameter<inputTag>("srcByReference"))),
sourceByValueToken_(consumes<reco::JetFlavourMatchingCollection>(iConfig.getParameter<inputTag>("srcByValue")))

Suppose we are interested in the flavour from the JetFlavourMatchingCollection. We can loop over jets and print out the flavour information with the following code:

for(reco::JetFlavourMatchingCollection::const_iterator j = theTagByValue->begin(); j != theTagByValue->end(); j++){
     RefToBase<Jet> aJet = (*j).first;
     const JetFlavour aFlav = (*j).second;
     // apply jet kinematic cuts
     if(aJet->pt() < jetPtMin_ || aJet->eta() < jetEtaMin_ || aJet->eta() > jetEtaMax_ ) continue;
     printf("[printJetFlavour] (pt, eta, phi) jet = %7.2f %6.3f %6.3f | (pt, eta, phi) parton = %7.2f %6.3f %6.3f | flav = %4d \n",
                aJet.get()->et(),
                aJet.get()->eta(),
                aJet.get()->phi(),
                aFlav.getLorentzVector().pt(),
                aFlav.getLorentzVector().eta(),
                aFlav.getLorentzVector().phi(),
                aFlav.getFlavour());
}

The output of your EDAnalyzer should look like this :

show hide

Begin processing the 1st record. Run 1, Event 1, LumiSection 1 on stream 0 at 03-Feb-2022 21:24:20.968 CET
..
analyzing event run: 1 lumi: 1 event: 15
-------------------- Jet Flavour by Value ------------------------
[printJetFlavour] (pt,eta,phi) jet =   33.27  0.074  0.951 | (pt, eta, phi) parton =    3.76  0.038  0.715 | flav =   21
[printJetFlavour] (pt,eta,phi) jet =   29.00 -0.486 -2.288 | (pt, eta, phi) parton =    0.00  0.000  0.000 | flav =    0
[printJetFlavour] (pt,eta,phi) jet =   27.49  0.817 -2.226 | (pt, eta, phi) parton =    0.00  0.000  0.000 | flav =    0
[printJetFlavour] (pt,eta,phi) jet =   24.59  1.042 -2.929 | (pt, eta, phi) parton =    4.97  1.382 -2.820 | flav =   21
[printJetFlavour] (pt,eta,phi) jet =   23.58 -1.111  3.048 | (pt, eta, phi) parton =    0.00  0.000  0.000 | flav =    0
[printJetFlavour] (pt,eta,phi) jet =   23.64 -0.302  2.910 | (pt, eta, phi) parton =    0.00  0.000  0.000 | flav =    0
Begin processing the 18th record. Run 1, Event 22, LumiSection 1 on stream 0 at 03-
...

Examples of how to retrieve jet flavour from the MatchedPartons can be seen in the full example code. Note that the value of the flavor can be zero if there was not a positive identification of jet flavour (for instance, no partons found inside the jet cone).

In summary,

• make changes to the EDAnalyzer so it looks like this
• make changes to the Build file so it looks like this
• make changes to the Configuration file so it looks like this

The above CMSSW 12.0 documentation is kept here

How to make Plots of b Tag Performance

Warning: Can't find topic CMSPublic.WorkBookBTagPerformance2XY

The above CMSSW 2.X and beyond documentation is kept here.

#Advancedtopics

Advanced topics

This section will cover additional topics related to b-tagging in CMSSW, in particular how to run a b-tag algorithm that was not included in the original data sample, or how to re-run some or all taggers with a different set of jets and/or tracks.

How to run a new tagger

Obtaining additional b-tag discriminators from the data stored in AOD is rather simple, as it only requires running the corresponding module. As an example, it will be shown how to run the softMuonByIP3d soft lepton tagger.

Add to your python configuration file the following snippet to take care of the general configuration (change the GlobalTag to match the dataset you are using):

# default configuration with frontier conditions
process.load("Configuration.StandardSequences.FrontierConditions_CMS.GlobalTag_cff")
process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("Configuration.StandardSequences.Geometry_cff")
process.GlobalTag.globaltag = 'IDEAL_V9::All'

# b-tagging general configuration
process.load("RecoBTag.Configuration.RecoBTag_cff")

Then add the configuration for the extra tagger you want to run - n this example, softMuonByIP3d. Usually both an ESProducer and EDProducer are needed, the first taking care of the algorithm configuration, the second of the b-tag raw data to use:

# configure the softMuonByIP3d ESProducer and EDProducer
process.load("RecoBTag.SoftLepton.softLeptonByIP3dES_cfi")
process.load("RecoBTag.SoftLepton.softMuonByIP3dBJetTags_cfi")

Finally, add the producer to a path, and run it:

# run the b-tag sequence
process.btag  = cms.Path( process.softMuonByIP3dBJetTags )

Of course, remember to add the new module(s) before any analysys code that will use them.

How to run on a different jet collection

Running the b-tag algorithms on a different jet collection requires access to the full RECO data.

Note: an alternative is to use the b-tag information precomputed with the default jet collection, matching the jets from the new collection to those from the original one.

In order to rerun all the algorithms on a different jet (or track) collection, one needs to duplicate the original b-tag sequence. Only the EDProducers needs to be cloned.

import FWCore.ParameterSet.Config as cms

# default configuration with frontier conditions
process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("Configuration.StandardSequences.Geometry_cff")
process.load("Configuration.StandardSequences.Reconstruction_cff")
process.load("Configuration.StandardSequences.FrontierConditions_CMS.GlobalTag_cff")
process.GlobalTag.globaltag = 'IDEAL_V9::All'

# b-tagging general configuration
process.load("RecoJets.JetAssociationProducers.ic5JetTracksAssociatorAtVertex_cfi")
process.load("RecoBTag.Configuration.RecoBTag_cff")

The first step is to clone the definition of the association between jets and tracks. This is where most of the customization will take place. As an example, here generalTracks and sisCone5CMS.CaloJets are used - to try different ones, change them to what you need throughout the configuration (check later the soft lepton part, too):

# create a new jets and tracks association
process.newJetTracksAssociatorAtVertex = process.ic5JetTracksAssociatorAtVertex.clone()
process.newJetTracksAssociatorAtVertex.jets = "sisCone5CMS.CaloJets"
process.newJetTracksAssociatorAtVertex.tracks = "generalTracks"

The one needs to clone the b-tag producers and instruct them to use this new collection. First the impact parameter-based b-tag:

# impact parameter b-tag
process.newImpactParameterTagInfos = process.impactParameterTagInfos.clone()
process.newImpactParameterTagInfos.jetTracks = "newJetTracksAssociatorAtVertex"
process.newTrackCountingHighEffBJetTags = process.trackCountingHighEffBJetTags.clone()
process.newTrackCountingHighEffBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )
process.newTrackCountingHighPurBJetTags = process.trackCountingHighPurBJetTags.clone()
process.newTrackCountingHighPurBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )
process.newJetProbabilityBJetTags = process.jetProbabilityBJetTags.clone()
process.newJetProbabilityBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )
process.newJetBProbabilityBJetTags = process.jetBProbabilityBJetTags.clone()
process.newJetBProbabilityBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") )

Then the secondary vertex-based b-tag. Note that these producers inherit the jets and tracks they use from the impact parameter modules: # secondary vertex b-tag
process.newSecondaryVertexTagInfos = process.secondaryVertexTagInfos.clone()
process.newSecondaryVertexTagInfos.trackIPTagInfos = "newImpactParameterTagInfos"
process.newSimpleSecondaryVertexBJetTags = process.simpleSecondaryVertexBJetTags.clone()
process.newSimpleSecondaryVertexBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newSecondaryVertexTagInfos") )
process.newCombinedSecondaryVertexBJetTags = process.combinedSecondaryVertexBJetTags.clone()
process.newCombinedSecondaryVertexBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos"), cms.InputTag("newSecondaryVertexTagInfos") )
process.newCombinedSecondaryVertexMVABJetTags = process.combinedSecondaryVertexMVABJetTags.clone()
process.newCombinedSecondaryVertexMVABJetTags.tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos"), cms.InputTag("newSecondaryVertexTagInfos") )

And the soft lepton b-tag. These producers will accept as input either the raw jets, or the association collection:

# soft electron b-tag
process.newSoftElectronTagInfos = process.softElectronTagInfos.clone()
process.newSoftElectronTagInfos.jets = "sisCone5CMS.CaloJets"
process.newSoftElectronBJetTags = process.softElectronBJetTags.clone()
process.newSoftElectronBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newSoftElectronTagInfos") )

# soft muon b-tag
process.newSoftMuonTagInfos = process.softMuonTagInfos.clone()
process.newSoftMuonTagInfos.jets = "sisCone5CMS.CaloJets"
process.newSoftMuonBJetTags = process.softMuonBJetTags.clone()
process.newSoftMuonBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") )
process.newSoftMuonByIP3dBJetTags = process.softMuonByIP3dBJetTags.clone()
process.newSoftMuonByIP3dBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") )
process.newSoftMuonByPtBJetTags = process.softMuonByPtBJetTags.clone()
process.newSoftMuonByPtBJetTags.tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") )

Finally, there needs to be a new path running all these modules

# prepare a path running the new modules
process.newJetTracksAssociator = cms.Sequence(
    process.newJetTracksAssociatorAtVertex
)

process.newJetBtaggingIP = cms.Sequence(
    process.newImpactParameterTagInfos * (
        process.newTrackCountingHighEffBJetTags +
        process.newTrackCountingHighPurBJetTags +
        process.newJetProbabilityBJetTags +
        process.newJetBProbabilityBJetTags
    )
)

process.newJetBtaggingSV = cms.Sequence(
    process.newImpactParameterTagInfos *
    process.newSecondaryVertexTagInfos * (
        process.newSimpleSecondaryVertexBJetTags +
        process.newCombinedSecondaryVertexBJetTags +
        process.newCombinedSecondaryVertexMVABJetTags
    )
)

process.newJetBtaggingEle = cms.Sequence(
    process.btagSoftElectrons *
    process.newSoftElectronTagInfos *
    process.newSoftElectronBJetTags
)

process.newJetBtaggingMu = cms.Sequence(
    process.newSoftMuonTagInfos * (
        process.newSoftMuonBJetTags +
        process.newSoftMuonByIP3dBJetTags +
        process.newSoftMuonByPtBJetTags
    )
)

process.newJetBtagging = cms.Sequence(
    process.newJetBtaggingIP +
    process.newJetBtaggingSV +
    process.newJetBtaggingEle +
    process.newJetBtaggingMu
)

process.newBtaggingPath = cms.Path(
    process.newJetTracksAssociator *
    process.newJetBtagging
)

Further Information

• b tag documentation in CMSSW software guide
• b tag group web page
• b tag hypernews

Review status

Responsible: AlexanderSchmidt & LucaScodellaro

Last reviewed by: JyothsnaK - 18-May-2010