diff --git a/DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h b/DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h index a790a7b2ca7d8..6b17fd05a2044 100644 --- a/DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h +++ b/DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h @@ -11,6 +11,7 @@ namespace btagbtvdeep { class ParticleTransformerAK4Features { public: + bool is_filled = true; std::vector sv_features; std::vector n_pf_features; diff --git a/PhysicsTools/NanoAOD/python/custom_jme_cff.py b/PhysicsTools/NanoAOD/python/custom_jme_cff.py index ab920cfaab0f0..4a93b44f5c2e9 100644 --- a/PhysicsTools/NanoAOD/python/custom_jme_cff.py +++ b/PhysicsTools/NanoAOD/python/custom_jme_cff.py @@ -25,7 +25,8 @@ 'pfDeepFlavourJetTags:probc','pfDeepFlavourJetTags:probuds','pfDeepFlavourJetTags:probg' ] from RecoBTag.ONNXRuntime.pfParticleNetAK4_cff import _pfParticleNetAK4JetTagsAll -bTagDiscriminatorsForAK4 = cms.PSet(foo = cms.vstring(bTagDeepCSV+bTagDeepJet+_pfParticleNetAK4JetTagsAll)) +from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll +bTagDiscriminatorsForAK4 = cms.PSet(foo = cms.vstring(bTagDeepJet+_pfParticleNetAK4JetTagsAll+_pfParticleTransformerAK4JetTagsAll)) run2_nanoAOD_ANY.toModify( bTagDiscriminatorsForAK4, foo = bTagCSVV2+bTagDeepCSV+bTagDeepJet+_pfParticleNetAK4JetTagsAll @@ -180,6 +181,15 @@ btagDeepFlavCvB = Var("?(pt>=15)&&(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(pt>=15)&&(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), ) +ROBUSTPARTAK4VARS = cms.PSet( + btagRobustParTAK4B = Var("?(pt>=15)?bDiscriminator('pfParticleTransformerAK4Tags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'):-1",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), + btagRobustParTAK4C = Var("?(pt>=15)?bDiscriminator('pfParticleTransformerAK4Tags:probc'):-1",float,doc="DeepFlavour charm tag raw score",precision=10), + btagRobustParTAK4G = Var("?(pt>=15)?bDiscriminator('pfParticleTransformerAK4Tags:probg'):-1",float,doc="DeepFlavour gluon tag raw score",precision=10), + btagRobustParTAK4UDS = Var("?(pt>=15)?bDiscriminator('pfParticleTransformerAK4Tags:probuds'):-1",float,doc="DeepFlavour uds tag raw score",precision=10), + btagRobustParTAK4CvL = Var("?(pt>=15)&&(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), + btagRobustParTAK4CvB = Var("?(pt>=15)&&(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), + btagRobustParTAK4QG = Var("?(pt>=15)&&(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probg')/(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), +) PARTICLENETAK4VARS = cms.PSet( particleNetAK4_B = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:BvsAll'):-1",float,doc="ParticleNetAK4 tagger b vs all (udsg, c) discriminator",precision=10), particleNetAK4_CvsL = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:CvsL'):-1",float,doc="ParticleNetAK4 tagger c vs udsg discriminator",precision=10), @@ -370,16 +380,16 @@ def AddBTaggingScores(proc, jetTableName=""): Store b-tagging scores from various algortihm """ - getattr(proc, jetTableName).variables.btagDeepB = BTAGVARS.btagDeepB - getattr(proc, jetTableName).variables.btagDeepCvL = BTAGVARS.btagDeepCvL - getattr(proc, jetTableName).variables.btagDeepCvB = BTAGVARS.btagDeepCvB getattr(proc, jetTableName).variables.btagDeepFlavB = DEEPJETVARS.btagDeepFlavB getattr(proc, jetTableName).variables.btagDeepFlavCvL = DEEPJETVARS.btagDeepFlavCvL getattr(proc, jetTableName).variables.btagDeepFlavCvB = DEEPJETVARS.btagDeepFlavCvB run2_nanoAOD_ANY.toModify( getattr(proc, jetTableName).variables, - btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) + btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10), + btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), + btagDeepCvL = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10), + btagDeepCvB = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10) ) return proc @@ -395,6 +405,17 @@ def AddDeepJetGluonLQuarkScores(proc, jetTableName=""): return proc +def AddRobustParTAK4Scores(proc, jetTableName=""): + """ + Store RobustParTAK4 scores in jetTable + """ + + getattr(proc, jetTableName).variables.btagRobustParTAK4B = ROBUSTPARTAK4VARS.btagRobustParTAK4B + getattr(proc, jetTableName).variables.btagRobustParTAK4CvL = ROBUSTPARTAK4VARS.btagRobustParTAK4CvL + getattr(proc, jetTableName).variables.btagRobustParTAK4CvB = ROBUSTPARTAK4VARS.btagRobustParTAK4CvB + + return proc + def AddParticleNetAK4Scores(proc, jetTableName=""): """ Store ParticleNetAK4 scores in jetTable @@ -574,6 +595,7 @@ def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTabl AddBTaggingScores(proc,jetTableName=jetTableName) AddDeepJetGluonLQuarkScores(proc,jetTableName=jetTableName) AddParticleNetAK4Scores(proc,jetTableName=jetTableName) + AddRobustParTAK4Scores(proc,jetTableName=jetTableName) return proc @@ -689,12 +711,6 @@ def ReclusterAK4PuppiJets(proc, recoJA, runOnMC): calculateQGLVars=True ) # - # Save standard b-tagging and c-tagging variables - # - proc.jetPuppiTable.variables.btagDeepB = BTAGVARS.btagDeepB - proc.jetPuppiTable.variables.btagDeepCvL = BTAGVARS.btagDeepCvL - proc.jetPuppiTable.variables.btagDeepCvB = BTAGVARS.btagDeepCvB - # # Save DeepJet b-tagging and c-tagging variables # proc.jetPuppiTable.variables.btagDeepFlavB = DEEPJETVARS.btagDeepFlavB @@ -707,6 +723,12 @@ def ReclusterAK4PuppiJets(proc, recoJA, runOnMC): proc.jetPuppiTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS proc.jetPuppiTable.variables.btagDeepFlavQG = DEEPJETVARS.btagDeepFlavQG # + # Save RobustParTAK4 b-tagging and c-tagging variables + # + proc.jetPuppiTable.variables.btagRobustParTAK4B = ROBUSTPARTAK4VARS.btagRobustParTAK4B + proc.jetPuppiTable.variables.btagRobustParTAK4CvL = ROBUSTPARTAK4VARS.btagRobustParTAK4CvL + proc.jetPuppiTable.variables.btagRobustParTAK4CvB = ROBUSTPARTAK4VARS.btagRobustParTAK4CvB + # # Add ParticleNetAK4 scores # proc.jetPuppiTable.variables.particleNetAK4_B = PARTICLENETAK4VARS.particleNetAK4_B @@ -881,6 +903,12 @@ def ReclusterAK4CHSJets(proc, recoJA, runOnMC): proc.jetTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS proc.jetTable.variables.btagDeepFlavQG = DEEPJETVARS.btagDeepFlavQG # + # Save RobustParTAK4 b-tagging and c-tagging variables + # + proc.jetTable.variables.btagRobustParTAK4B = ROBUSTPARTAK4VARS.btagRobustParTAK4B + proc.jetTable.variables.btagRobustParTAK4CvL = ROBUSTPARTAK4VARS.btagRobustParTAK4CvL + proc.jetTable.variables.btagRobustParTAK4CvB = ROBUSTPARTAK4VARS.btagRobustParTAK4CvB + # # Add ParticleNetAK4 scores # proc.jetTable.variables.particleNetAK4_B = PARTICLENETAK4VARS.particleNetAK4_B diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 693f4d7acf74c..3d45018f7d0bc 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -134,13 +134,26 @@ svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", "int16", doc="index of first matching secondary vertex"), svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", "int16", doc="index of second matching secondary vertex"), nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", "uint8", doc="number of secondary vertices in the jet"), - btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), - btagDeepCvL = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10), - btagDeepCvB = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10), + btagRobustParTAK4B = Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')", + float, + doc="RobustParTAK4 b+bb+lepb tag discriminator", + precision=10), btagDeepFlavCvL = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), + btagRobustParTAK4CvL = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg')):-1", + float, + doc="RobustParTAK4 c vs uds+g discriminator", + precision=10), + btagRobustParTAK4CvB = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1", + float, + doc="RobustParTAK4 c vs b+bb+lepb discriminator", + precision=10), + btagRobustParTAK4QG = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probg')/(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')):-1", + float, + doc="RobustParTAK4 g vs uds discriminator", + precision=10), btagPNetB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg"), btagPNetCvL = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="ParticleNet c vs. udsg"), btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), @@ -190,7 +203,10 @@ run2_nanoAOD_ANY.toModify( jetTable.variables, - btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) + btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10), + btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), + btagDeepCvL = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10), + btagDeepCvB = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10) ) (run3_nanoAOD_122 | run3_nanoAOD_124).toModify( @@ -355,7 +371,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet): +def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet,addRobustParTAK4=False): _btagDiscriminators=[] if addDeepBTag: print("Updating process to run DeepCSV btag") @@ -369,6 +385,11 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet) from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll + if addRobustParTAK4: + print("Updating process to run RobustParTAK4") + from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll as pfParticleTransformerAK4JetTagsAll + _btagDiscriminators += pfParticleTransformerAK4JetTagsAll + if len(_btagDiscriminators)==0: return process print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) updateJetCollection( @@ -386,7 +407,8 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet) nanoAOD_addDeepInfoAK4CHS_switch = cms.PSet( nanoAOD_addDeepBTag_switch = cms.untracked.bool(False), nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(False), - nanoAOD_addParticleNet_switch = cms.untracked.bool(False) + nanoAOD_addParticleNet_switch = cms.untracked.bool(False), + nanoAOD_addRobustParTAK4Tag_switch = cms.untracked.bool(False) ) ################################################ diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 726318cdb3c5c..91ff1a97deefe 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -81,13 +81,14 @@ svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", "int16", doc="index of first matching secondary vertex"), svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", "int16", doc="index of second matching secondary vertex"), nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", "uint8", doc="number of secondary vertices in the jet"), - btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), - btagDeepCvL = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10), - btagDeepCvB = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10), + btagRobustParTAK4B = Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')",float,doc="RobustParTAK4 b+bb+lepb tag discriminator",precision=10), btagDeepFlavCvL = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), + btagRobustParTAK4CvL = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg')):-1",float,doc="RobustParTAK4 c vs uds+g discriminator",precision=10), + btagRobustParTAK4CvB = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="RobustParTAK4 c vs b+bb+lepb discriminator",precision=10), + btagRobustParTAK4QG = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probg')/(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')):-1",float,doc="RobustParTAK4 g vs uds discriminator",precision=10), btagPNetB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg"), btagPNetCvL = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="ParticleNet c vs. udsg"), btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), @@ -113,7 +114,10 @@ run2_nanoAOD_ANY.toModify( jetPuppiTable.variables, - btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10) + btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10), + btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), + btagDeepCvL = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10), + btagDeepCvB = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10) ) (run3_nanoAOD_122 | run3_nanoAOD_124).toModify( @@ -137,7 +141,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK4(process,addParticleNet): +def nanoAOD_addDeepInfoAK4(process,addParticleNet,addRobustParTAK4=False): _btagDiscriminators=[] if addParticleNet: print("Updating process to run ParticleNetAK4") @@ -145,6 +149,10 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet): from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll _btagDiscriminators += pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll + if addRobustParTAK4: + print("Updating process to run RobustParTAK4") + from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll as pfParticleTransformerAK4JetTagsAll + _btagDiscriminators += pfParticleTransformerAK4JetTagsAll if len(_btagDiscriminators)==0: return process print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) updateJetCollection( @@ -160,7 +168,8 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet): return process nanoAOD_addDeepInfoAK4_switch = cms.PSet( - nanoAOD_addParticleNet_switch = cms.untracked.bool(False) + nanoAOD_addParticleNet_switch = cms.untracked.bool(False), + nanoAOD_addRobustParTAK4Tag_switch = cms.untracked.bool(False) ) ################################################ diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py index 07d91111000af..e0dd163096ae3 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cff.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cff.py @@ -95,6 +95,11 @@ def _match(name): _Jet_Run2_plots.append(plot) _Jet_Run2_plots.extend([ Plot1D('btagCSVV2', 'btagCSVV2', 20, -1, 1, ' pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)'), + Plot1D('btagCMVA', 'btagCMVA', 20, -1, 1, 'CMVA V2 btag discriminator'), + Plot1D('btagDeepB', 'btagDeepB', 20, -1, 1, 'Deep B+BB btag discriminator'), + Plot1D('btagDeepC', 'btagDeepC', 20, 0, 1, 'DeepCSV charm btag discriminator'), + Plot1D('btagDeepCvB', 'btagDeepCvB', 20, -1, 1, 'DeepCSV c vs b+bb discriminator'), + Plot1D('btagDeepCvL', 'btagDeepCvL', 20, -1, 1, 'DeepCSV c vs udsg discriminator') ]) _Jet_EarlyRun3_plots = cms.VPSet() diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py index f126d1da55eff..a3b3af589f85a 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py @@ -405,16 +405,15 @@ Plot1D('area', 'area', 20, 0.2, 0.8, 'jet catchment area, for JECs'), Plot1D('bRegCorr', 'bRegCorr', 20, 0, 3, 'pt correction for b-jet energy regression'), Plot1D('bRegRes', 'bRegRes', 20, 0, 0.6, 'res on pt corrected with b-jet regression'), - Plot1D('btagCMVA', 'btagCMVA', 20, -1, 1, 'CMVA V2 btag discriminator'), - Plot1D('btagDeepB', 'btagDeepB', 20, -1, 1, 'Deep B+BB btag discriminator'), - Plot1D('btagDeepC', 'btagDeepC', 20, 0, 1, 'DeepCSV charm btag discriminator'), - Plot1D('btagDeepCvB', 'btagDeepCvB', 20, -1, 1, 'DeepCSV c vs b+bb discriminator'), - Plot1D('btagDeepCvL', 'btagDeepCvL', 20, -1, 1, 'DeepCSV c vs udsg discriminator'), Plot1D('btagDeepFlavB', 'btagDeepFlavB', 20, 0, 1, 'DeepFlavour b+bb tag discriminator'), Plot1D('btagDeepFlavC', 'btagDeepFlavC', 20, 0, 1, 'DeepFlavour charm tag discriminator'), Plot1D('btagDeepFlavCvB', 'btagDeepFlavCvB', 20, -1, 1, 'DeepJet c vs b+bb+lepb discriminator'), Plot1D('btagDeepFlavCvL', 'btagDeepFlavCvL', 20, -1, 1, 'DeepJet c vs uds+g discriminator'), Plot1D('btagDeepFlavQG', 'btagDeepFlavQG', 20, -1, 1, 'DeepJet g vs uds discriminator'), + Plot1D('btagRobustParTAK4B', 'btagRobustParTAK4B', 20, 0, 1, 'RobustParTAK4 b+bb+lepb tag discriminator'), + Plot1D('btagRobustParTAK4CvB', 'btagRobustParTAK4CvB', 20, -1, 1, 'RobustParTAK4 c vs b+bb+lepb discriminator'), + Plot1D('btagRobustParTAK4CvL', 'btagRobustParTAK4CvL', 20, -1, 1, 'RobustParTAK4 c vs uds+g discriminator'), + Plot1D('btagRobustParTAK4QG', 'btagRobustParTAK4QG', 20, -1, 1, 'RobustParTAK4 g vs uds discriminator'), Plot1D('cRegCorr', 'cRegCorr', 20, 0.6, 2, 'pt correction for c-jet energy regression'), Plot1D('cRegRes', 'cRegRes', 20, 0.05, 0.4, 'res on pt corrected with c-jet regression'), Plot1D('btagPNetB', 'btagPNetB', 20, 0, 1, 'ParticleNet b tag discriminator'), diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index 1786b0016ef87..12d1b1c6cab3f 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -157,19 +157,22 @@ def nanoAOD_customizeCommon(process): process = nanoAOD_activateVID(process) run2_nanoAOD_106Xv2.toModify( - nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch=True, + nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch=True, + nanoAOD_addRobustParTAK4Tag_switch=True, ) # This function is defined in jetsAK4_Puppi_cff.py process = nanoAOD_addDeepInfoAK4(process, - addParticleNet=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addParticleNet_switch + addParticleNet=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addParticleNet_switch, + addRobustParTAK4=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addRobustParTAK4Tag_switch ) # This function is defined in jetsAK4_CHS_cff.py process = nanoAOD_addDeepInfoAK4CHS(process, addDeepBTag=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepBTag_switch, addDeepFlavour=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepFlavourTag_switch, - addParticleNet=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addParticleNet_switch + addParticleNet=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addParticleNet_switch, + addRobustParTAK4=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addRobustParTAK4Tag_switch ) # This function is defined in jetsAK8_cff.py diff --git a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py index c31f7f94d2bad..361c2fd2814ae 100644 --- a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py +++ b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py @@ -41,6 +41,8 @@ # DeepFlavour tag infos , 'pfDeepFlavourTagInfos' , 'pfNegativeDeepFlavourTagInfos' + # ParticleTransformerAK4 tag infos + , 'pfParticleTransformerAK4TagInfos' # DeepDoubleB/C tag infos , 'pfDeepDoubleXTagInfos' # DeepBoostedJet tag infos @@ -198,6 +200,12 @@ , 'pfDeepFlavourJetTags:probc' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfDeepFlavourJetTags:probuds' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfDeepFlavourJetTags:probg' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfParticleTransformerAK4JetTags:probb' : [["pfParticleTransformerAK4TagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfParticleTransformerAK4JetTags:probbb' : [["pfParticleTransformerAK4TagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfParticleTransformerAK4JetTags:problepb' : [["pfParticleTransformerAK4TagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfParticleTransformerAK4JetTags:probc' : [["pfParticleTransformerAK4TagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfParticleTransformerAK4JetTags:probuds' : [["pfParticleTransformerAK4TagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] + , 'pfParticleTransformerAK4JetTags:probg' : [["pfParticleTransformerAK4TagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfDeepVertexJetTags:probb' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfDeepCombinedJetTags:probb' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] , 'pfDeepCombinedJetTags:probc' : [["pfDeepFlavourTagInfos"], ['pfDeepCSVTagInfos', "pfImpactParameterTagInfos", 'pfInclusiveSecondaryVertexFinderTagInfos']] @@ -319,3 +327,14 @@ for disc in _pfHiggsInteractionNetTagsProbs: supportedBtagDiscr[disc] = [["pfHiggsInteractionNetTagInfos"]] # ----------------------------------- + +# ----------------------------------- +# setup ParticleTransformer AK4 +from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsProbs, _pfParticleTransformerAK4JetTagsMetaDiscrs +# update supportedBtagDiscr +for disc in _pfParticleTransformerAK4JetTagsProbs + _pfParticleTransformerAK4JetTagsMetaDiscrs: + supportedBtagDiscr[disc] = [["pfParticleTransformerAK4TagInfos"]] +# update supportedMetaDiscr +for disc in _pfParticleTransformerAK4JetTagsMetaDiscrs: + supportedMetaDiscr[disc] = _pfParticleTransformerAK4JetTagsProbs +# ----------------------------------- diff --git a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py index 7b1ae50bb45ca..f566769f6b4ee 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -14,6 +14,7 @@ def applyDeepBtagging(process, postfix=""): from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll as pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll as pfParticleTransformerAK4JetTagsAll # update slimmed jets to include DeepFlavour (keep same name) # make clone for DeepFlavour-less slimmed jets, so output name is preserved @@ -28,6 +29,7 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:probg') + pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll + pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll + + pfParticleTransformerAK4JetTagsAll ) updateJetCollection( process, @@ -64,6 +66,7 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:probg') + pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll + pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll + + pfParticleTransformerAK4JetTagsAll ) updateJetCollection( diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index 669db367cfa86..c164f83fe2380 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -437,7 +437,7 @@ def _add_deepFlavour(process): def _add_jetsPuppi(process): from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection noDeepFlavourDiscriminators = [x.value() if isinstance(x, cms.InputTag) else x for x in process.patJets.discriminatorSources - if not "DeepFlavour" in str(x)] + if (not "DeepFlavour" in str(x) and not "Transformer" in str(x))] addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'), jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''), pfCandidates = cms.InputTag("particleFlow"), diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 5d64bb5c8ae2e..a8256e7144f63 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -640,7 +640,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = False # use right input tags when running with RECO PF candidates, which actually - # depens of wether jets use "particleFlow" + # depends of whether jets use "particleFlow" if pfCandidates.value() == 'packedPFCandidates': puppi_value_map = setupPackedPuppi(process) vertex_associator = cms.InputTag("") @@ -663,7 +663,38 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou is_weighted_jet = is_weighted_jet, flip = flip), process, task) - + + if 'ParticleTransformerAK4TagInfos' in btagInfo: + svUsed = svSource + if btagInfo == 'pfNegativeParticleTransformerAK4TagInfos': + svUsed = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix) + flip = True + else: + flip = False + # use right input tags when running with RECO PF candidates, which actually + # depends of whether jets use "particleFlow" + if pfCandidates.value() == 'packedPFCandidates': + puppi_value_map = setupPackedPuppi(process) + vertex_associator = cms.InputTag("") + else: + puppi_value_map = cms.InputTag("puppi") + vertex_associator = cms.InputTag("primaryVertexAssociation","original") + + # If this jet is a puppi jet, then set is_weighted_jet to true. + is_weighted_jet = False + if ('puppi' in jetSource.value().lower()): + is_weighted_jet = True + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + btag.pfParticleTransformerAK4TagInfos.clone( + jets = jetSource, + vertices=pvSource, + secondary_vertices=svUsed, + puppi_value_map = puppi_value_map, + vertex_associator = vertex_associator, + is_weighted_jet = is_weighted_jet, + flip = flip), + process, task) + if btagInfo == 'pfDeepDoubleXTagInfos': # can only run on PAT jets, so the updater needs to be used if 'updated' not in jetSource.value().lower(): diff --git a/RecoBTag/Configuration/python/RecoBTag_cff.py b/RecoBTag/Configuration/python/RecoBTag_cff.py index 30fad5b537327..fab7ac28b3475 100644 --- a/RecoBTag/Configuration/python/RecoBTag_cff.py +++ b/RecoBTag/Configuration/python/RecoBTag_cff.py @@ -13,6 +13,7 @@ from RecoBTag.ONNXRuntime.pfHiggsInteractionNet_cff import * from RecoBTag.ONNXRuntime.pfParticleNet_cff import * from RecoBTag.ONNXRuntime.pfParticleNetAK4_cff import * +from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import * from RecoVertex.AdaptiveVertexFinder.inclusiveVertexing_cff import * from RecoBTag.PixelCluster.pixelClusterTagInfos_cfi import * diff --git a/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h b/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h index f88f01b3daf7c..02dc62ce7384d 100644 --- a/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h +++ b/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h @@ -20,7 +20,8 @@ namespace btagbtvdeep { const float& jetR, const float& puppiw, ChargedCandidateFeatures& c_pf_features, - const bool flip = false) { + const bool flip = false, + const float& distminpfcandsv = 0) { float trackSip2dVal = track_info.getTrackSip2dVal(); float trackSip2dSig = track_info.getTrackSip2dSig(); float trackSip3dVal = track_info.getTrackSip3dVal(); @@ -58,10 +59,19 @@ namespace btagbtvdeep { c_pf_features.btagPf_trackJetDistVal = catch_infs_and_bound(track_info.getTrackJetDistVal(), 0, -20, 1); c_pf_features.drminsv = catch_infs_and_bound(drminpfcandsv, 0, -1. * jetR, 0, -1. * jetR); + c_pf_features.distminsv = distminpfcandsv; std::pair drSubjetFeatures = getDRSubjetFeatures(jet, c_pf); c_pf_features.drsubjet1 = drSubjetFeatures.first; c_pf_features.drsubjet2 = drSubjetFeatures.second; + + c_pf_features.pt = c_pf->pt(); + c_pf_features.eta = c_pf->eta(); + c_pf_features.phi = c_pf->phi(); + c_pf_features.e = c_pf->energy(); + c_pf_features.px = c_pf->px(); + c_pf_features.py = c_pf->py(); + c_pf_features.pz = c_pf->pz(); } void packedCandidateToFeatures(const pat::PackedCandidate* c_pf, @@ -72,7 +82,8 @@ namespace btagbtvdeep { const float jetR, const float puppiw, ChargedCandidateFeatures& c_pf_features, - const bool flip = false); + const bool flip = false, + const float distminpfcandsv = 0); void recoCandidateToFeatures(const reco::PFCandidate* c_pf, const reco::Jet& jet, @@ -84,7 +95,8 @@ namespace btagbtvdeep { const int pv_ass_quality, const reco::VertexRef& pv, ChargedCandidateFeatures& c_pf_features, - const bool flip = false); + const bool flip = false, + const float distminpfcandsv = 0); } // namespace btagbtvdeep diff --git a/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h b/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h index 1b6d4a9170ae1..755a5f9fc7873 100644 --- a/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h +++ b/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h @@ -56,6 +56,16 @@ namespace btagbtvdeep { n_pf_features.isGamma = 1; n_pf_features.drminsv = catch_infs_and_bound(drminpfcandsv, 0, -1. * jetR, 0, -1. * jetR); + + n_pf_features.etarel = catch_infs_and_bound(std::fabs(n_pf->eta() - jet.eta()), 0, -2, 0, -0.5); + n_pf_features.phirel = catch_infs_and_bound(std::fabs(reco::deltaPhi(n_pf->phi(), jet.phi())), 0, -2, 0, -0.5); + n_pf_features.pt = n_pf->pt(); + n_pf_features.eta = n_pf->eta(); + n_pf_features.phi = n_pf->phi(); + n_pf_features.e = n_pf->energy(); + n_pf_features.px = n_pf->px(); + n_pf_features.py = n_pf->py(); + n_pf_features.pz = n_pf->pz(); } } // namespace btagbtvdeep diff --git a/RecoBTag/FeatureTools/interface/deep_helpers.h b/RecoBTag/FeatureTools/interface/deep_helpers.h index 2786a99260662..d0f50b63efa5b 100644 --- a/RecoBTag/FeatureTools/interface/deep_helpers.h +++ b/RecoBTag/FeatureTools/interface/deep_helpers.h @@ -5,6 +5,7 @@ #include "DataFormats/BTauReco/interface/TaggingVariable.h" #include "TrackingTools/IPTools/interface/IPTools.h" +#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h" #include "DataFormats/BTauReco/interface/CandIPTagInfo.h" @@ -81,6 +82,9 @@ namespace btagbtvdeep { const reco::Candidate *cand, float mindr = 0.4); + // compute minimum distance between SVs and a candidate (from DeepNTuples, now polymorphic) + float mindistsvpfcand(const std::vector &svs, const reco::TransientTrack track); + // mimic the calculation in PackedCandidate float vtx_ass_from_pfcand(const reco::PFCandidate &pfcand, int pv_ass_quality, const reco::VertexRef &pv); float quality_from_pfcand(const reco::PFCandidate &pfcand); diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc new file mode 100644 index 0000000000000..1d66657ccc822 --- /dev/null +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -0,0 +1,425 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" +#include "FWCore/Utilities/interface/ESGetToken.h" + +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/BTauReco/interface/ShallowTagInfo.h" + +#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h" +#include "TrackingTools/Records/interface/TransientTrackRecord.h" + +#include "DataFormats/BTauReco/interface/ParticleTransformerAK4TagInfo.h" +#include "DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h" + +#include "RecoBTag/FeatureTools/interface/JetConverter.h" +#include "RecoBTag/FeatureTools/interface/ShallowTagInfoConverter.h" +#include "RecoBTag/FeatureTools/interface/SecondaryVertexConverter.h" +#include "RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h" +#include "RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h" + +#include "RecoBTag/FeatureTools/interface/TrackInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/sorting_modules.h" + +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" + +#include "RecoBTag/FeatureTools/interface/deep_helpers.h" + +#include "FWCore/ParameterSet/interface/Registry.h" +#include "FWCore/Common/interface/Provenance.h" +#include "DataFormats/Provenance/interface/ProductProvenance.h" + +#include "DataFormats/BTauReco/interface/SeedingTrackFeatures.h" +#include "DataFormats/BTauReco/interface/TrackPairFeatures.h" +#include "RecoBTag/FeatureTools/interface/TrackPairInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/SeedingTrackInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/SeedingTracksConverter.h" + +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "RecoBTag/TrackProbability/interface/HistogramProbabilityEstimator.h" +class HistogramProbabilityEstimator; +#include + +#include +#include "CondFormats/BTauObjects/interface/TrackProbabilityCalibration.h" +#include "CondFormats/DataRecord/interface/BTagTrackProbability2DRcd.h" +#include "CondFormats/DataRecord/interface/BTagTrackProbability3DRcd.h" +#include "FWCore/Framework/interface/EventSetupRecord.h" +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" +#include "FWCore/Framework/interface/EventSetupRecordKey.h" + +class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { +public: + explicit ParticleTransformerAK4TagInfoProducer(const edm::ParameterSet&); + ~ParticleTransformerAK4TagInfoProducer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + typedef std::vector ParticleTransformerAK4TagInfoCollection; + typedef reco::VertexCompositePtrCandidateCollection SVCollection; + typedef reco::VertexCollection VertexCollection; + + void beginStream(edm::StreamID) override {} + void produce(edm::Event&, const edm::EventSetup&) override; + void endStream() override {} + + const double jet_radius_; + const double min_candidate_pt_; + const bool flip_; + + const edm::EDGetTokenT> jet_token_; + const edm::EDGetTokenT vtx_token_; + const edm::EDGetTokenT sv_token_; + edm::EDGetTokenT> puppi_value_map_token_; + edm::EDGetTokenT> pvasq_value_map_token_; + edm::EDGetTokenT> pvas_token_; + const edm::EDGetTokenT> candidateToken_; + const edm::ESGetToken track_builder_token_; + bool use_puppi_value_map_; + bool use_pvasq_value_map_; + + const bool fallback_puppi_weight_; + const bool fallback_vertex_association_; + + const bool is_weighted_jet_; + + const double min_jet_pt_; + const double max_jet_eta_; +}; + +ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(const edm::ParameterSet& iConfig) + : jet_radius_(iConfig.getParameter("jet_radius")), + min_candidate_pt_(iConfig.getParameter("min_candidate_pt")), + flip_(iConfig.getParameter("flip")), + jet_token_(consumes>(iConfig.getParameter("jets"))), + vtx_token_(consumes(iConfig.getParameter("vertices"))), + sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), + candidateToken_(consumes>(iConfig.getParameter("candidates"))), + track_builder_token_( + esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))), + use_puppi_value_map_(false), + use_pvasq_value_map_(false), + fallback_puppi_weight_(iConfig.getParameter("fallback_puppi_weight")), + fallback_vertex_association_(iConfig.getParameter("fallback_vertex_association")), + is_weighted_jet_(iConfig.getParameter("is_weighted_jet")), + min_jet_pt_(iConfig.getParameter("min_jet_pt")), + max_jet_eta_(iConfig.getParameter("max_jet_eta")) { + produces(); + + const auto& puppi_value_map_tag = iConfig.getParameter("puppi_value_map"); + if (!puppi_value_map_tag.label().empty()) { + puppi_value_map_token_ = consumes>(puppi_value_map_tag); + use_puppi_value_map_ = true; + } else if (is_weighted_jet_) { + throw edm::Exception(edm::errors::Configuration, + "puppi_value_map is not set but jet is weighted. Must set puppi_value_map."); + } + + const auto& pvas_tag = iConfig.getParameter("vertex_associator"); + if (!pvas_tag.label().empty()) { + pvasq_value_map_token_ = consumes>(pvas_tag); + pvas_token_ = consumes>(pvas_tag); + use_pvasq_value_map_ = true; + } +} + +void ParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // pfParticleTransformerAK4TagInfos + edm::ParameterSetDescription desc; + desc.add("jet_radius", 0.4); + desc.add("min_candidate_pt", 0.95); + desc.add("flip", false); + desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("puppi_value_map", edm::InputTag("puppi")); + desc.add("secondary_vertices", edm::InputTag("inclusiveCandidateSecondaryVertices")); + desc.add("jets", edm::InputTag("ak4PFJetsCHS")); + desc.add("candidates", edm::InputTag("packedPFCandidates")); + desc.add("vertex_associator", edm::InputTag("primaryVertexAssociation", "original")); + desc.add("fallback_puppi_weight", false); + desc.add("fallback_vertex_association", false); + desc.add("is_weighted_jet", false); + desc.add("min_jet_pt", 15.0); + desc.add("max_jet_eta", 2.5); + descriptions.add("pfParticleTransformerAK4TagInfos", desc); +} + +void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + auto output_tag_infos = std::make_unique(); + edm::Handle> jets; + iEvent.getByToken(jet_token_, jets); + + edm::Handle vtxs; + iEvent.getByToken(vtx_token_, vtxs); + if (vtxs->empty()) { + // produce empty TagInfos in case no primary vertex + iEvent.put(std::move(output_tag_infos)); + return; // exit event + } + // reference to primary vertex + const auto& pv = vtxs->at(0); + + edm::Handle> tracks; + iEvent.getByToken(candidateToken_, tracks); + + edm::Handle svs; + iEvent.getByToken(sv_token_, svs); + + edm::Handle> puppi_value_map; + if (use_puppi_value_map_) { + iEvent.getByToken(puppi_value_map_token_, puppi_value_map); + } + + edm::Handle> pvasq_value_map; + edm::Handle> pvas; + if (use_pvasq_value_map_) { + iEvent.getByToken(pvasq_value_map_token_, pvasq_value_map); + iEvent.getByToken(pvas_token_, pvas); + } + + edm::ESHandle track_builder = iSetup.getHandle(track_builder_token_); + + for (std::size_t jet_n = 0; jet_n < jets->size(); jet_n++) { + // create data containing structure + btagbtvdeep::ParticleTransformerAK4Features features; + + // reco jet reference (use as much as possible) + const auto& jet = jets->at(jet_n); + if (jet.pt() < 15.0) { + features.is_filled = false; + } + if (std::abs(jet.eta()) > 2.5) { + features.is_filled = false; + } + // dynamical casting to pointers, null if not possible + const auto* pf_jet = dynamic_cast(&jet); + const auto* pat_jet = dynamic_cast(&jet); + edm::RefToBase jet_ref(jets, jet_n); + + if (features.is_filled) { + math::XYZVector jet_dir = jet.momentum().Unit(); + GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz()); + + // copy which will be sorted + auto svs_sorted = *svs; + // sort by dxy + std::sort(svs_sorted.begin(), svs_sorted.end(), [&pv](const auto& sva, const auto& svb) { + return btagbtvdeep::sv_vertex_comparator(sva, svb, pv); + }); + // fill features from secondary vertices + for (const auto& sv : svs_sorted) { + if (reco::deltaR2(sv, jet_dir) > (jet_radius_ * jet_radius_)) + continue; + else { + features.sv_features.emplace_back(); + // in C++17 could just get from emplace_back output + auto& sv_features = features.sv_features.back(); + btagbtvdeep::svToFeatures(sv, pv, jet, sv_features, flip_); + } + } + + // stuff required for dealing with pf candidates + + std::vector> c_sorted, n_sorted; + + // to cache the TrackInfo + std::map trackinfos; + + // unsorted reference to sv + const auto& svs_unsorted = *svs; + // fill collection, from DeepTNtuples plus some styling + for (unsigned int i = 0; i < jet.numberOfDaughters(); i++) { + auto cand = jet.daughter(i); + if (cand) { + // candidates under 950MeV (configurable) are not considered + // might change if we use also white-listing + if (cand->pt() < min_candidate_pt_) + continue; + if (cand->charge() != 0) { + auto& trackinfo = trackinfos.emplace(i, track_builder).first->second; + trackinfo.buildTrackInfo(cand, jet_dir, jet_ref_track_dir, pv); + + c_sorted.emplace_back(i, + trackinfo.getTrackSip2dSig(), + -btagbtvdeep::mindrsvpfcand(svs_unsorted, cand), + cand->pt() / jet.pt()); + } else { + n_sorted.emplace_back(i, -1, -btagbtvdeep::mindrsvpfcand(svs_unsorted, cand), cand->pt() / jet.pt()); + } + } + } + + // sort collections (open the black-box if you please) + std::sort(c_sorted.begin(), c_sorted.end(), btagbtvdeep::SortingClass::compareByABCInv); + std::sort(n_sorted.begin(), n_sorted.end(), btagbtvdeep::SortingClass::compareByABCInv); + + std::vector c_sortedindices, n_sortedindices; + + // this puts 0 everywhere and the right position in ind + c_sortedindices = btagbtvdeep::invertSortingVector(c_sorted); + n_sortedindices = btagbtvdeep::invertSortingVector(n_sorted); + + // set right size to vectors + features.c_pf_features.clear(); + features.c_pf_features.resize(c_sorted.size()); + features.n_pf_features.clear(); + features.n_pf_features.resize(n_sorted.size()); + + for (unsigned int i = 0; i < jet.numberOfDaughters(); i++) { + // get pointer and check that is correct + auto cand = dynamic_cast(jet.daughter(i)); + if (!cand) + continue; + // candidates under 950MeV are not considered + // might change if we use also white-listing + if (cand->pt() < 0.95) + continue; + + auto packed_cand = dynamic_cast(cand); + auto reco_cand = dynamic_cast(cand); + + // need some edm::Ptr or edm::Ref if reco candidates + reco::PFCandidatePtr reco_ptr; + if (pf_jet) { + reco_ptr = pf_jet->getPFConstituent(i); + } else if (pat_jet && reco_cand) { + reco_ptr = pat_jet->getPFConstituent(i); + } + + reco::CandidatePtr cand_ptr; + if (pat_jet) { + cand_ptr = pat_jet->sourceCandidatePtr(i); + } + + // + // Access puppi weight from ValueMap. + // + float puppiw = 1.0; // Set to fallback value + + if (reco_cand) { + if (use_puppi_value_map_) + puppiw = (*puppi_value_map)[reco_ptr]; + else if (!fallback_puppi_weight_) { + throw edm::Exception(edm::errors::InvalidReference, "PUPPI value map missing") + << "use fallback_puppi_weight option to use " << puppiw << " for reco_cand as default"; + } + } else if (packed_cand) { + if (use_puppi_value_map_) + puppiw = (*puppi_value_map)[cand_ptr]; + else if (!fallback_puppi_weight_) { + throw edm::Exception(edm::errors::InvalidReference, "PUPPI value map missing") + << "use fallback_puppi_weight option to use " << puppiw << " for packed_cand as default"; + } + } else { + throw edm::Exception(edm::errors::InvalidReference) + << "Cannot convert to either reco::PFCandidate or pat::PackedCandidate"; + } + + float drminpfcandsv = btagbtvdeep::mindrsvpfcand(svs_unsorted, cand); + float distminpfcandsv = 0; + if (cand->charge() != 0) { + // is charged candidate + auto entry = c_sortedindices.at(i); + + // get cached track info + auto& trackinfo = trackinfos.at(i); + + // get_ref to vector element + auto& c_pf_features = features.c_pf_features.at(entry); + // fill feature structure + if (packed_cand) { + if (packed_cand->hasTrackDetails()) { + const reco::Track& PseudoTrack = packed_cand->pseudoTrack(); + reco::TransientTrack transientTrack; + transientTrack = track_builder->build(PseudoTrack); + distminpfcandsv = btagbtvdeep::mindistsvpfcand(svs_unsorted, transientTrack); + } + + btagbtvdeep::packedCandidateToFeatures(packed_cand, + jet, + trackinfo, + is_weighted_jet_, + drminpfcandsv, + static_cast(jet_radius_), + puppiw, + c_pf_features, + flip_, + distminpfcandsv); + } else if (reco_cand) { + // get vertex association quality + int pv_ass_quality = 0; // fallback value + if (use_pvasq_value_map_) { + pv_ass_quality = (*pvasq_value_map)[reco_ptr]; + } else if (!fallback_vertex_association_) { + throw edm::Exception(edm::errors::InvalidReference, "vertex association missing") + << "use fallback_vertex_association option to use" << pv_ass_quality + << "as default quality and closest dz PV as criteria"; + } + // getting the PV as PackedCandidatesProducer + // but using not the slimmed but original vertices + auto ctrack = reco_cand->bestTrack(); + int pvi = -1; + float dist = 1e99; + for (size_t ii = 0; ii < vtxs->size(); ii++) { + float dz = (ctrack) ? std::abs(ctrack->dz(((*vtxs)[ii]).position())) : 0; + if (dz < dist) { + pvi = ii; + dist = dz; + } + } + auto PV = reco::VertexRef(vtxs, pvi); + if (use_pvasq_value_map_) { + const reco::VertexRef& PV_orig = (*pvas)[reco_ptr]; + if (PV_orig.isNonnull()) + PV = reco::VertexRef(vtxs, PV_orig.key()); + } + btagbtvdeep::recoCandidateToFeatures(reco_cand, + jet, + trackinfo, + is_weighted_jet_, + drminpfcandsv, + static_cast(jet_radius_), + puppiw, + pv_ass_quality, + PV, + c_pf_features, + flip_, + distminpfcandsv); + } + } else { + // is neutral candidate + auto entry = n_sortedindices.at(i); + // get_ref to vector element + auto& n_pf_features = features.n_pf_features.at(entry); + // fill feature structure + if (packed_cand) { + btagbtvdeep::packedCandidateToFeatures(packed_cand, + jet, + is_weighted_jet_, + drminpfcandsv, + static_cast(jet_radius_), + puppiw, + n_pf_features); + } else if (reco_cand) { + btagbtvdeep::recoCandidateToFeatures( + reco_cand, jet, is_weighted_jet_, drminpfcandsv, static_cast(jet_radius_), puppiw, n_pf_features); + } + } + } + } + output_tag_infos->emplace_back(features, jet_ref); + } + iEvent.put(std::move(output_tag_infos)); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(ParticleTransformerAK4TagInfoProducer); diff --git a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc index 84d0fdb2d1cca..5209c7d2818c4 100644 --- a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc +++ b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc @@ -10,8 +10,10 @@ namespace btagbtvdeep { const float jetR, const float puppiw, ChargedCandidateFeatures& c_pf_features, - const bool flip) { - commonCandidateToFeatures(c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, c_pf_features, flip); + const bool flip, + const float distminpfcandsv) { + commonCandidateToFeatures( + c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, c_pf_features, flip, distminpfcandsv); c_pf_features.vtx_ass = c_pf->pvAssociationQuality(); @@ -46,8 +48,10 @@ namespace btagbtvdeep { const int pv_ass_quality, const reco::VertexRef& pv, ChargedCandidateFeatures& c_pf_features, - const bool flip) { - commonCandidateToFeatures(c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, c_pf_features, flip); + const bool flip, + const float distminpfcandsv) { + commonCandidateToFeatures( + c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, c_pf_features, flip, distminpfcandsv); c_pf_features.vtx_ass = vtx_ass_from_pfcand(*c_pf, pv_ass_quality, pv); c_pf_features.puppiw = puppiw; diff --git a/RecoBTag/FeatureTools/src/SecondaryVertexConverter.cc b/RecoBTag/FeatureTools/src/SecondaryVertexConverter.cc index 78b346840ae0f..5302326796b55 100644 --- a/RecoBTag/FeatureTools/src/SecondaryVertexConverter.cc +++ b/RecoBTag/FeatureTools/src/SecondaryVertexConverter.cc @@ -17,6 +17,14 @@ namespace btagbtvdeep { math::XYZVector jet_dir = jet.momentum().Unit(); sv_features.pt = sv.pt(); sv_features.ptrel = sv.pt() / jet.pt(); + sv_features.etarel = catch_infs_and_bound(std::fabs(sv.eta() - jet.eta()) - 0.5, 0, -2, 0); + sv_features.phirel = catch_infs_and_bound(std::fabs(reco::deltaPhi(sv.phi(), jet.phi())) - 0.5, 0, -2, 0); + sv_features.eta = sv.eta(); + sv_features.phi = sv.phi(); + sv_features.e = sv.energy(); + sv_features.px = sv.px(); + sv_features.py = sv.py(); + sv_features.pz = sv.pz(); sv_features.deltaR = catch_infs_and_bound(std::fabs(reco::deltaR(sv, jet_dir)) - 0.5, 0, -2, 0); sv_features.mass = sv.mass(); sv_features.ntracks = sv.numberOfDaughters(); diff --git a/RecoBTag/FeatureTools/src/deep_helpers.cc b/RecoBTag/FeatureTools/src/deep_helpers.cc index 3d0d407ff85a8..76b443542b334 100644 --- a/RecoBTag/FeatureTools/src/deep_helpers.cc +++ b/RecoBTag/FeatureTools/src/deep_helpers.cc @@ -1,7 +1,20 @@ #include "RecoBTag/FeatureTools/interface/deep_helpers.h" #include "DataFormats/PatCandidates/interface/PackedCandidate.h" #include "FWCore/Utilities/interface/isFinite.h" - +#include "TrackingTools/Records/interface/TransientTrackRecord.h" +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" +#include "TrackingTools/GeomPropagators/interface/AnalyticalTrajectoryExtrapolatorToLine.h" +#include "TrackingTools/GeomPropagators/interface/AnalyticalImpactPointExtrapolator.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "TLorentzVector.h" +#include "DataFormats/Math/interface/deltaR.h" +#include "RecoVertex/VertexTools/interface/VertexDistance3D.h" +#include "RecoVertex/VertexTools/interface/VertexDistanceXY.h" +#include "RecoVertex/VertexPrimitives/interface/ConvertToFromReco.h" +#include "RecoVertex/VertexPrimitives/interface/VertexState.h" namespace btagbtvdeep { constexpr static int qualityMap[8] = {1, 0, 1, 1, 4, 4, 5, 6}; @@ -81,6 +94,56 @@ namespace btagbtvdeep { return mindr; } + // compute minimum distance between SVs and a candidate (from DeepNTuples, now polymorphic) + float mindistsvpfcand(const std::vector &svs, const reco::TransientTrack track) { + float mindist_ = 999.999; + float out_dist = 0.0; + for (unsigned int i = 0; i < svs.size(); ++i) { + if (!track.isValid()) { + continue; + } + reco::Vertex::CovarianceMatrix csv; + svs[i].fillVertexCovariance(csv); + reco::Vertex vertex(svs[i].vertex(), csv); + if (!vertex.isValid()) { + continue; + } + + GlobalVector direction(svs[i].px(), svs[i].py(), svs[i].pz()); + + AnalyticalImpactPointExtrapolator extrapolator(track.field()); + TrajectoryStateOnSurface tsos = + extrapolator.extrapolate(track.impactPointState(), RecoVertex::convertPos(vertex.position())); + + VertexDistance3D dist; + + if (!tsos.isValid()) { + continue; + } + GlobalPoint refPoint = tsos.globalPosition(); + GlobalError refPointErr = tsos.cartesianError().position(); + GlobalPoint vertexPosition = RecoVertex::convertPos(vertex.position()); + GlobalError vertexPositionErr = RecoVertex::convertError(vertex.error()); + + std::pair result( + true, dist.distance(VertexState(vertexPosition, vertexPositionErr), VertexState(refPoint, refPointErr))); + if (!result.first) { + continue; + } + + GlobalPoint impactPoint = tsos.globalPosition(); + GlobalVector IPVec(impactPoint.x() - vertex.x(), impactPoint.y() - vertex.y(), impactPoint.z() - vertex.z()); + double prod = IPVec.dot(direction); + double sign = (prod >= 0) ? 1. : -1.; + + if (result.second.value() < mindist_) { + out_dist = sign * result.second.value(); + mindist_ = result.second.value(); + } + } + return out_dist; + } + // instantiate template template bool sv_vertex_comparator( const reco::VertexCompositePtrCandidate &, const reco::VertexCompositePtrCandidate &, const reco::Vertex &); diff --git a/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc index 10dacfcd5e819..b958dc84629c0 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc @@ -79,8 +79,8 @@ void DeepFlavourONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescript edm::ParameterSetDescription desc; desc.add("src", edm::InputTag("pfDeepFlavourTagInfos")); desc.add>("input_names", {"input_1", "input_2", "input_3", "input_4", "input_5"}); - desc.add("model_path", - edm::FileInPath("RecoBTag/Combined/data/DeepFlavourV03_10X_training/model.onnx")); + desc.add( + "model_path", edm::FileInPath("RecoBTag/Combined/data/DeepFlavourV04_12X_training/DeepJet_Run3_122X.onnx")); desc.add>("output_names", {"ID_pred/Softmax:0"}); desc.add>( "flav_names", std::vector{"probb", "probbb", "problepb", "probc", "probuds", "probg"}); @@ -110,7 +110,7 @@ void DeepFlavourONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::Even // init data storage data_.clear(); for (const auto& len : input_sizes_) { - data_.emplace_back(tag_infos->size() * len, 0); + data_.emplace_back(tag_infos->size() * len, 0.0); } // convert inputs diff --git a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc new file mode 100644 index 0000000000000..b27a9b397e520 --- /dev/null +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -0,0 +1,296 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/Framework/interface/makeRefToBaseProdFrom.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" + +#include "DataFormats/BTauReco/interface/JetTag.h" + +#include "DataFormats/BTauReco/interface/ParticleTransformerAK4TagInfo.h" +#include "DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h" + +#include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" + +using namespace cms::Ort; + +class ParticleTransformerAK4ONNXJetTagsProducer : public edm::stream::EDProducer> { +public: + explicit ParticleTransformerAK4ONNXJetTagsProducer(const edm::ParameterSet&, const ONNXRuntime*); + ~ParticleTransformerAK4ONNXJetTagsProducer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions&); + + static std::unique_ptr initializeGlobalCache(const edm::ParameterSet&); + static void globalEndJob(const ONNXRuntime*); + +private: + typedef std::vector TagInfoCollection; + typedef reco::JetTagCollection JetTagCollection; + + void produce(edm::Event&, const edm::EventSetup&) override; + + void make_inputs(btagbtvdeep::ParticleTransformerAK4Features features); + void get_input_sizes(const reco::FeaturesTagInfo taginfo); + + const edm::EDGetTokenT src_; + std::vector flav_names_; + std::vector input_names_; + std::vector output_names_; + + enum InputIndexes { + kChargedCandidates = 0, + kNeutralCandidates = 1, + kVertices = 2, + kChargedCandidates4Vec = 3, + kNeutralCandidates4Vec = 4, + kVertices4Vec = 5 + }; + unsigned n_cpf_; + constexpr static unsigned n_features_cpf_ = 16; + constexpr static unsigned n_pairwise_features_cpf_ = 4; + unsigned n_npf_; + constexpr static unsigned n_features_npf_ = 8; + constexpr static unsigned n_pairwise_features_npf_ = 4; + unsigned n_sv_; + constexpr static unsigned n_features_sv_ = 14; + constexpr static unsigned n_pairwise_features_sv_ = 4; + std::vector input_sizes_; + std::vector> input_shapes_; // shapes of each input group (-1 for dynamic axis) + + // hold the input data + FloatArrays data_; +}; + +ParticleTransformerAK4ONNXJetTagsProducer::ParticleTransformerAK4ONNXJetTagsProducer(const edm::ParameterSet& iConfig, + const ONNXRuntime* cache) + : src_(consumes(iConfig.getParameter("src"))), + flav_names_(iConfig.getParameter>("flav_names")), + input_names_(iConfig.getParameter>("input_names")), + output_names_(iConfig.getParameter>("output_names")) { + // get output names from flav_names + for (const auto& flav_name : flav_names_) { + produces(flav_name); + } +} + +void ParticleTransformerAK4ONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // pfParticleTransformerAK4JetTags + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag("pfParticleTransformerAK4TagInfos")); + desc.add>("input_names", {"input_1", "input_2", "input_3", "input_4", "input_5", "input_6"}); + desc.add("model_path", + edm::FileInPath("RecoBTag/Combined/data/RobustParTAK4/PUPPI/V00/RobustParTAK4.onnx")); + desc.add>("output_names", {"softmax"}); + desc.add>( + "flav_names", std::vector{"probb", "probbb", "problepb", "probc", "probuds", "probg"}); + + descriptions.add("pfParticleTransformerAK4JetTags", desc); +} + +std::unique_ptr ParticleTransformerAK4ONNXJetTagsProducer::initializeGlobalCache( + const edm::ParameterSet& iConfig) { + return std::make_unique(iConfig.getParameter("model_path").fullPath()); +} + +void ParticleTransformerAK4ONNXJetTagsProducer::globalEndJob(const ONNXRuntime* cache) {} + +void ParticleTransformerAK4ONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle tag_infos; + iEvent.getByToken(src_, tag_infos); + + // initialize output collection + std::vector> output_tags; + if (!tag_infos->empty()) { + auto jet_ref = tag_infos->begin()->jet(); + auto ref2prod = edm::makeRefToBaseProdFrom(jet_ref, iEvent); + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique(ref2prod)); + } + } else { + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique()); + } + } + + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& taginfo = (*tag_infos)[jet_n]; + std::vector outputs(flav_names_.size(), -1.0); + if (taginfo.features().is_filled) { + get_input_sizes(taginfo); + + // run prediction with dynamic batch size per event + input_shapes_ = {{(int64_t)1, (int64_t)n_cpf_, (int64_t)n_features_cpf_}, + {(int64_t)1, (int64_t)n_npf_, (int64_t)n_features_npf_}, + {(int64_t)1, (int64_t)n_sv_, (int64_t)n_features_sv_}, + {(int64_t)1, (int64_t)n_cpf_, (int64_t)n_pairwise_features_cpf_}, + {(int64_t)1, (int64_t)n_npf_, (int64_t)n_pairwise_features_npf_}, + {(int64_t)1, (int64_t)n_sv_, (int64_t)n_pairwise_features_sv_}}; + + outputs = globalCache()->run(input_names_, data_, input_shapes_, output_names_, 1)[0]; + assert(outputs.size() == flav_names_.size()); + } + + const auto& jet_ref = tag_infos->at(jet_n).jet(); + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { + (*(output_tags[flav_n]))[jet_ref] = outputs[flav_n]; + } + } + + // put into the event + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); ++flav_n) { + iEvent.put(std::move(output_tags[flav_n]), flav_names_[flav_n]); + } +} + +void ParticleTransformerAK4ONNXJetTagsProducer::get_input_sizes( + const reco::FeaturesTagInfo taginfo) { + const auto& features = taginfo.features(); + + unsigned int n_cpf = features.c_pf_features.size(); + unsigned int n_npf = features.n_pf_features.size(); + unsigned int n_vtx = features.sv_features.size(); + + n_cpf_ = std::max((unsigned int)1, n_cpf); + n_npf_ = std::max((unsigned int)1, n_npf); + n_sv_ = std::max((unsigned int)1, n_vtx); + + n_cpf_ = std::min((unsigned int)25, n_cpf_); + n_npf_ = std::min((unsigned int)25, n_npf_); + n_sv_ = std::min((unsigned int)5, n_sv_); + input_sizes_ = { + n_cpf_ * n_features_cpf_, + n_npf_ * n_features_npf_, + n_sv_ * n_features_sv_, + n_cpf_ * n_pairwise_features_cpf_, + n_npf_ * n_pairwise_features_npf_, + n_sv_ * n_pairwise_features_sv_, + }; + // init data storage + data_.clear(); + for (const auto& len : input_sizes_) { + data_.emplace_back(1 * len, 0); + } + + make_inputs(features); +} + +void ParticleTransformerAK4ONNXJetTagsProducer::make_inputs(btagbtvdeep::ParticleTransformerAK4Features features) { + float* ptr = nullptr; + const float* start = nullptr; + unsigned offset = 0; + + // c_pf candidates + auto max_c_pf_n = std::min(features.c_pf_features.size(), (std::size_t)n_cpf_); + for (std::size_t c_pf_n = 0; c_pf_n < max_c_pf_n; c_pf_n++) { + const auto& c_pf_features = features.c_pf_features.at(c_pf_n); + ptr = &data_[kChargedCandidates][offset + c_pf_n * n_features_cpf_]; + start = ptr; + *ptr = c_pf_features.btagPf_trackEtaRel; + *(++ptr) = c_pf_features.btagPf_trackPtRel; + *(++ptr) = c_pf_features.btagPf_trackPPar; + *(++ptr) = c_pf_features.btagPf_trackDeltaR; + *(++ptr) = c_pf_features.btagPf_trackPParRatio; + *(++ptr) = c_pf_features.btagPf_trackSip2dVal; + *(++ptr) = c_pf_features.btagPf_trackSip2dSig; + *(++ptr) = c_pf_features.btagPf_trackSip3dVal; + *(++ptr) = c_pf_features.btagPf_trackSip3dSig; + *(++ptr) = c_pf_features.btagPf_trackJetDistVal; + *(++ptr) = c_pf_features.ptrel; + *(++ptr) = c_pf_features.drminsv; + *(++ptr) = c_pf_features.vtx_ass; + *(++ptr) = c_pf_features.puppiw; + *(++ptr) = c_pf_features.chi2; + *(++ptr) = c_pf_features.quality; + assert(start + n_features_cpf_ - 1 == ptr); + } + + // n_pf candidates + auto max_n_pf_n = std::min(features.n_pf_features.size(), (std::size_t)n_npf_); + for (std::size_t n_pf_n = 0; n_pf_n < max_n_pf_n; n_pf_n++) { + const auto& n_pf_features = features.n_pf_features.at(n_pf_n); + ptr = &data_[kNeutralCandidates][offset + n_pf_n * n_features_npf_]; + start = ptr; + *ptr = n_pf_features.ptrel; + *(++ptr) = n_pf_features.etarel; + *(++ptr) = n_pf_features.phirel; + *(++ptr) = n_pf_features.deltaR; + *(++ptr) = n_pf_features.isGamma; + *(++ptr) = n_pf_features.hadFrac; + *(++ptr) = n_pf_features.drminsv; + *(++ptr) = n_pf_features.puppiw; + assert(start + n_features_npf_ - 1 == ptr); + } + + // sv candidates + auto max_sv_n = std::min(features.sv_features.size(), (std::size_t)n_sv_); + for (std::size_t sv_n = 0; sv_n < max_sv_n; sv_n++) { + const auto& sv_features = features.sv_features.at(sv_n); + ptr = &data_[kVertices][offset + sv_n * n_features_sv_]; + start = ptr; + *ptr = sv_features.pt; + *(++ptr) = sv_features.deltaR; + *(++ptr) = sv_features.mass; + *(++ptr) = sv_features.etarel; + *(++ptr) = sv_features.phirel; + *(++ptr) = sv_features.ntracks; + *(++ptr) = sv_features.chi2; + *(++ptr) = sv_features.normchi2; + *(++ptr) = sv_features.dxy; + *(++ptr) = sv_features.dxysig; + *(++ptr) = sv_features.d3d; + *(++ptr) = sv_features.d3dsig; + *(++ptr) = sv_features.costhetasvpv; + *(++ptr) = sv_features.enratio; + assert(start + n_features_sv_ - 1 == ptr); + } + + // cpf pairwise features (4-vectors) + auto max_cpf_n = std::min(features.c_pf_features.size(), (std::size_t)n_cpf_); + for (std::size_t cpf_n = 0; cpf_n < max_cpf_n; cpf_n++) { + const auto& cpf_pairwise_features = features.c_pf_features.at(cpf_n); + ptr = &data_[kChargedCandidates4Vec][offset + cpf_n * n_pairwise_features_cpf_]; + start = ptr; + *ptr = cpf_pairwise_features.px; + *(++ptr) = cpf_pairwise_features.py; + *(++ptr) = cpf_pairwise_features.pz; + *(++ptr) = cpf_pairwise_features.e; + + assert(start + n_pairwise_features_cpf_ - 1 == ptr); + } + + // npf pairwise features (4-vectors) + auto max_npf_n = std::min(features.n_pf_features.size(), (std::size_t)n_npf_); + for (std::size_t npf_n = 0; npf_n < max_npf_n; npf_n++) { + const auto& npf_pairwise_features = features.n_pf_features.at(npf_n); + ptr = &data_[kNeutralCandidates4Vec][offset + npf_n * n_pairwise_features_npf_]; + start = ptr; + *ptr = npf_pairwise_features.px; + *(++ptr) = npf_pairwise_features.py; + *(++ptr) = npf_pairwise_features.pz; + *(++ptr) = npf_pairwise_features.e; + + assert(start + n_pairwise_features_npf_ - 1 == ptr); + } + + // sv pairwise features (4-vectors) + auto max_sv_N = std::min(features.sv_features.size(), (std::size_t)n_sv_); + for (std::size_t sv_N = 0; sv_N < max_sv_N; sv_N++) { + const auto& sv_pairwise_features = features.sv_features.at(sv_N); + ptr = &data_[kVertices4Vec][offset + sv_N * n_pairwise_features_sv_]; + start = ptr; + *ptr = sv_pairwise_features.px; + *(++ptr) = sv_pairwise_features.py; + *(++ptr) = sv_pairwise_features.pz; + *(++ptr) = sv_pairwise_features.e; + + assert(start + n_pairwise_features_sv_ - 1 == ptr); + } +} + +//define this as a plug-in +DEFINE_FWK_MODULE(ParticleTransformerAK4ONNXJetTagsProducer); diff --git a/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4DiscriminatorsJetTags_cfi.py b/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4DiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..d90eefec0f9af --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4DiscriminatorsJetTags_cfi.py @@ -0,0 +1,72 @@ +import FWCore.ParameterSet.Config as cms + +pfParticleTransformerAK4DiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('BvsAll'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'problepb'), + ), + denominator=cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'problepb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probc'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probuds'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('BvsL'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'problepb'), + ), + denominator=cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'problepb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probuds'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsL'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probc'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probuds'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsB'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probc'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'problepb'), + ), + ), + cms.PSet( + name = cms.string('QvsG'), + numerator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probuds'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfParticleTransformerAK4JetTags', 'probuds'), + cms.InputTag('pfParticleTransformerAK4JetTags', 'probg'), + ), + ), + + ) + ) diff --git a/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py new file mode 100644 index 0000000000000..0fb1c8ceac050 --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py @@ -0,0 +1,29 @@ +import FWCore.ParameterSet.Config as cms + +from RecoBTag.FeatureTools.pfParticleTransformerAK4TagInfos_cfi import pfParticleTransformerAK4TagInfos + +from RecoBTag.ONNXRuntime.pfParticleTransformerAK4JetTags_cfi import pfParticleTransformerAK4JetTags +from RecoBTag.ONNXRuntime.pfParticleTransformerAK4DiscriminatorsJetTags_cfi import pfParticleTransformerAK4DiscriminatorsJetTags +from CommonTools.PileupAlgos.Puppi_cff import puppi +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation + +# declare all the discriminators +# probs +_pfParticleTransformerAK4JetTagsProbs = ['pfParticleTransformerAK4JetTags:' + flav_name + for flav_name in pfParticleTransformerAK4JetTags.flav_names] +# meta-taggers +_pfParticleTransformerAK4JetTagsMetaDiscrs = ['pfParticleTransformerAK4DiscriminatorsJetTags:' + disc.name.value() + for disc in pfParticleTransformerAK4DiscriminatorsJetTags.discriminators] +_pfParticleTransformerAK4JetTagsAll = _pfParticleTransformerAK4JetTagsProbs + _pfParticleTransformerAK4JetTagsMetaDiscrs + + + +# == +# This task is not used, useful only if we run it from RECO jets (RECO/AOD) +pfParticleTransformerAK4Task = cms.Task(puppi, primaryVertexAssociation, + pfParticleTransformerAK4TagInfos, pfParticleTransformerAK4JetTags, + pfParticleTransformerAK4DiscriminatorsJetTags) +# run from MiniAOD instead +pfParticleTransformerAK4FromMiniAODTask = cms.Task(pfParticleTransformerAK4TagInfos, + pfParticleTransformerAK4JetTags, + pfParticleTransformerAK4DiscriminatorsJetTags)