From 6ad7665bded02590f1b7be8492e0d771b692b464 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Wed, 29 Mar 2023 10:12:25 +0200 Subject: [PATCH 01/17] ParTAK4 V00 for 131X --- PhysicsTools/NanoAOD/python/custom_jme_cff.py | 36 +- .../NanoAOD/python/jetsAK4_CHS_cff.py | 30 +- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 12 +- PhysicsTools/NanoAOD/python/nano_cff.py | 3 +- .../python/recoLayer0/bTagging_cff.py | 19 + .../python/slimming/applyDeepBtagging_cff.py | 5 +- .../PatAlgos/python/slimming/miniAOD_tools.py | 2 +- .../PatAlgos/python/tools/jetTools.py | 25 +- RecoBTag/Configuration/python/RecoBTag_cff.py | 1 + .../interface/ChargedCandidateConverter.h | 24 +- .../interface/NeutralCandidateConverter.h | 10 + .../FeatureTools/interface/deep_helpers.h | 5 + .../ParticleTransformerAK4TagInfoProducer.cc | 427 ++++++++++++++++++ .../src/ChargedCandidateConverter.cc | 10 +- .../src/SecondaryVertexConverter.cc | 8 + RecoBTag/FeatureTools/src/deep_helpers.cc | 65 ++- ...rticleTransformerAK4ONNXJetTagsProducer.cc | 320 +++++++++++++ ...TransformerAK4DiscriminatorsJetTags_cfi.py | 72 +++ .../python/pfParticleTransformerAK4_cff.py | 25 + RecoBTag/ONNXRuntime/test/plotParTAK4.py | 190 ++++++++ RecoBTag/ONNXRuntime/test/step1_NANO.py | 124 +++++ RecoBTag/ONNXRuntime/test/step1_PAT.py | 215 +++++++++ 22 files changed, 1602 insertions(+), 26 deletions(-) create mode 100644 RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc create mode 100644 RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc create mode 100644 RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4DiscriminatorsJetTags_cfi.py create mode 100644 RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py create mode 100644 RecoBTag/ONNXRuntime/test/plotParTAK4.py create mode 100644 RecoBTag/ONNXRuntime/test/step1_NANO.py create mode 100644 RecoBTag/ONNXRuntime/test/step1_PAT.py diff --git a/PhysicsTools/NanoAOD/python/custom_jme_cff.py b/PhysicsTools/NanoAOD/python/custom_jme_cff.py index ab920cfaab0f0..b4ce4c37bee5d 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(bTagDeepCSV+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), @@ -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 @@ -707,6 +729,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 +909,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 3d67fe82bdc11..4496f2f159659 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('pfParticleTransformerAK4etTags: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), puIdDisc = Var("userFloat('puIdNanoDisc')", float,doc="Pileup ID discriminant with 106X (2018) training",precision=10), puId = Var("userInt('puIdNanoId')", "uint8", doc="Pileup ID flags with 106X (2018) training"), jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8", doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"), @@ -182,7 +195,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) ) bjetNN = cms.EDProducer("BJetEnergyRegressionMVA", @@ -335,7 +351,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour): +def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addRobustParTAK4): _btagDiscriminators=[] if addDeepBTag: print("Updating process to run DeepCSV btag") @@ -343,6 +359,9 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour): if addDeepFlavour: print("Updating process to run DeepFlavour btag") _btagDiscriminators += ['pfDeepFlavourJetTags:probb','pfDeepFlavourJetTags:probbb','pfDeepFlavourJetTags:problepb','pfDeepFlavourJetTags:probc'] + if addRobustParTAK4: + print("Updating process to run RobustParTAK4 btag") + _btagDiscriminators += ['pfParticleTransformerAK4JetTags:probb','pfParticleTransformerAK4JetTags:probbb','pfParticleTransformerAK4JetTags:problepb','pfParticleTransformerAK4JetTags:probc'] if len(_btagDiscriminators)==0: return process print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) updateJetCollection( @@ -360,6 +379,7 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour): nanoAOD_addDeepInfoAK4CHS_switch = cms.PSet( nanoAOD_addDeepBTag_switch = cms.untracked.bool(False), nanoAOD_addDeepFlavourTag_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 0ac78ba5cf357..9261136a8bf3d 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -80,13 +80,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('pfParticleTransformerAK4etTags: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), jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8",doc="Jet ID flag: bit2 is tight, bit3 is tightLepVeto"), hfsigmaEtaEta = Var("userFloat('hfsigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10), hfsigmaPhiPhi = Var("userFloat('hfsigmaPhiPhi')",float,doc="sigmaPhiPhi for HF jets (noise discriminating variable)",precision=10), @@ -105,7 +106,10 @@ from PhysicsTools.NanoAOD.nano_eras_cff import run2_nanoAOD_ANY 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) ) #jets are not as precise as muons diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index d10ba5084fe2d..ffff26604f1b7 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -158,7 +158,8 @@ def nanoAOD_customizeCommon(process): # 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 + addDeepFlavour=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepFlavourTag_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 7231fb8196915..96fb1949cbb5b 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 @@ -192,6 +194,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']] @@ -287,3 +295,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 937e910a87797..91c0e14c69b40 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -10,6 +10,7 @@ def applyDeepBtagging(process, postfix=""): from PhysicsTools.PatAlgos.slimming.slimmedJets_cfi import slimmedJets, slimmedJetsAK8 from RecoBTag.ONNXRuntime.pfParticleNetAK4_cff import _pfParticleNetAK4JetTagsAll as pfParticleNetAK4JetTagsAll + 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 @@ -21,7 +22,7 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:problepb', 'pfDeepFlavourJetTags:probc', 'pfDeepFlavourJetTags:probuds', - 'pfDeepFlavourJetTags:probg') + 'pfDeepFlavourJetTags:probg') + pfParticleTransformerAK4JetTagsAll ) updateJetCollection( process, @@ -55,7 +56,7 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:problepb', 'pfDeepFlavourJetTags:probc', 'pfDeepFlavourJetTags:probuds', - 'pfDeepFlavourJetTags:probg') + pfParticleNetAK4JetTagsAll + 'pfDeepFlavourJetTags:probg') + pfParticleNetAK4JetTagsAll + pfParticleTransformerAK4JetTagsAll ) updateJetCollection( process, diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index bff1bfb7ed5d8..3db89f5747781 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -439,7 +439,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 c217ce6eb9b3c..0c32d01caf0b8 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -644,7 +644,30 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou vertex_associator = vertex_associator, 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 + if not ('limmed' in jetSource.value()): + puppi_value_map = cms.InputTag("puppi") + vertex_associator = cms.InputTag("primaryVertexAssociation","original") + else: + puppi_value_map = cms.InputTag("") + vertex_associator = cms.InputTag("") + 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, + 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 6ea872004da65..21dcb466d1038 100644 --- a/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h +++ b/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h @@ -18,7 +18,8 @@ namespace btagbtvdeep { const float& drminpfcandsv, const float& jetR, 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(); @@ -50,10 +51,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; + 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, @@ -62,7 +72,8 @@ namespace btagbtvdeep { const float drminpfcandsv, const float jetR, 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, @@ -73,7 +84,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 6af3e44fc7de3..1ede64bac631f 100644 --- a/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h +++ b/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h @@ -45,6 +45,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..9802343b50128 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,10 @@ 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..441a92ba5f0d5 --- /dev/null +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -0,0 +1,427 @@ +#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; + + 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_; + + edm::EDGetTokenT> jet_token_; + edm::EDGetTokenT vtx_token_; + edm::EDGetTokenT sv_token_; + edm::EDGetTokenT> puppi_value_map_token_; + edm::EDGetTokenT> pvasq_value_map_token_; + edm::EDGetTokenT> pvas_token_; + edm::EDGetTokenT> candidateToken_; + edm::ESGetToken track_builder_token_; + edm::ESGetToken calib2d_token_; + edm::ESGetToken calib3d_token_; + + bool use_puppi_value_map_; + bool use_pvasq_value_map_; + + bool fallback_puppi_weight_; + bool fallback_vertex_association_; + + //TrackProbability + void checkEventSetup(const edm::EventSetup& iSetup); + std::unique_ptr probabilityEstimator_; + bool compute_probabilities_; + unsigned long long calibrationCacheId2D_; + unsigned long long calibrationCacheId3D_; + + 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")), + compute_probabilities_(iConfig.getParameter("compute_probabilities")), + 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; + } + + 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; + } + if (compute_probabilities_) { + calib2d_token_ = esConsumes(); + calib3d_token_ = esConsumes(); + } +} + +ParticleTransformerAK4TagInfoProducer::~ParticleTransformerAK4TagInfoProducer() {} + +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("compute_probabilities", 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(); + if (compute_probabilities_) + checkEventSetup(iSetup); + + 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_); + + //std::vector selectedTracks; + //std::vector masses; + + 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){continue;} + // 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); + + 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); + } + // get PUPPI weight from value map + float puppiw = 1.0; // fallback value + if (reco_cand && use_puppi_value_map_) { + puppiw = (*puppi_value_map)[reco_ptr]; + } else if (reco_cand && !fallback_puppi_weight_) { + throw edm::Exception(edm::errors::InvalidReference, "PUPPI value map missing") + << "use fallback_puppi_weight option to use " << puppiw << "as default"; + } + + 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, + drminpfcandsv, + static_cast(jet_radius_), + 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, + 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, drminpfcandsv, static_cast(jet_radius_), n_pf_features); + } else if (reco_cand) { + btagbtvdeep::recoCandidateToFeatures( + reco_cand, 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)); +} + +void ParticleTransformerAK4TagInfoProducer::checkEventSetup(const edm::EventSetup& iSetup) { + using namespace edm; + using namespace edm::eventsetup; + + const EventSetupRecord& re2D = iSetup.get(); + const EventSetupRecord& re3D = iSetup.get(); + unsigned long long cacheId2D = re2D.cacheIdentifier(); + unsigned long long cacheId3D = re3D.cacheIdentifier(); + if (cacheId2D != calibrationCacheId2D_ || cacheId3D != calibrationCacheId3D_) //Calibration changed + { + ESHandle calib2DHandle = iSetup.getHandle(calib2d_token_); + ESHandle calib3DHandle = iSetup.getHandle(calib3d_token_); + probabilityEstimator_ = + std::make_unique(calib3DHandle.product(), calib2DHandle.product()); + } + + calibrationCacheId3D_ = cacheId3D; + calibrationCacheId2D_ = cacheId2D; +} + +//define this as a plug-in +DEFINE_FWK_MODULE(ParticleTransformerAK4TagInfoProducer); \ No newline at end of file diff --git a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc index c05455d398c08..1c9fb83d61c57 100644 --- a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc +++ b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc @@ -8,8 +8,9 @@ namespace btagbtvdeep { const float drminpfcandsv, const float jetR, ChargedCandidateFeatures& c_pf_features, - const bool flip) { - commonCandidateToFeatures(c_pf, jet, track_info, drminpfcandsv, jetR, c_pf_features, flip); + const bool flip, + const float distminpfcandsv) { + commonCandidateToFeatures(c_pf, jet, track_info, drminpfcandsv, jetR, c_pf_features, flip, distminpfcandsv); c_pf_features.vtx_ass = c_pf->pvAssociationQuality(); @@ -43,8 +44,9 @@ namespace btagbtvdeep { const int pv_ass_quality, const reco::VertexRef& pv, ChargedCandidateFeatures& c_pf_features, - const bool flip) { - commonCandidateToFeatures(c_pf, jet, track_info, drminpfcandsv, jetR, c_pf_features, flip); + const bool flip, + const float distminpfcandsv) { + commonCandidateToFeatures(c_pf, jet, track_info, drminpfcandsv, jetR, 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..454defc859f7c 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}; @@ -80,7 +93,57 @@ 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/ParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc new file mode 100644 index 0000000000000..ea8b5222fcdac --- /dev/null +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -0,0 +1,320 @@ +#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 "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; + + 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(unsigned i_jet, const reco::ParticleTransformerAK4TagInfo& taginfo); + void get_input_sizes(edm::Handle tag_infos); + + 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_ = 17; + 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); + } + +} + +ParticleTransformerAK4ONNXJetTagsProducer::~ParticleTransformerAK4ONNXJetTagsProducer() {} + +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/Run2/V00/RobustParTAK4_Run2.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); + + std::vector> output_tags; + if (!tag_infos->empty()) { + // initialize output collection + 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)); + } + get_input_sizes(tag_infos); + + // init data storage + data_.clear(); + for (const auto& len : input_sizes_) { + data_.emplace_back(tag_infos->size() * len, 0); + } + // convert inputs + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& taginfo = (*tag_infos)[jet_n]; + make_inputs(jet_n, taginfo); + } + // run prediction with dynamic batch size per event + input_shapes_ = { + {(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_features_cpf_}, + {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_features_npf_}, + {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_features_sv_}, + {(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_pairwise_features_cpf_}, + {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_pairwise_features_npf_}, + {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_pairwise_features_sv_} + }; + + auto outputs = globalCache()->run(input_names_, data_, input_shapes_, output_names_, tag_infos->size())[0]; + assert(outputs.size() == flav_names_.size() * tag_infos->size()); + + // get the outputs + unsigned i_output = 0; + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + 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[i_output]; + ++i_output; + } + } + } else { + // create empty output collection + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique()); + } + } + + // 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(edm::Handle tag_infos){ + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& taginfo = (*tag_infos)[jet_n]; + 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(); + + if (jet_n == 0){ + 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); + } + else{ + n_cpf_ = std::max(n_cpf_, n_cpf); + n_npf_ = std::max(n_npf_, n_npf); + n_sv_ = std::max(n_sv_, 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_, + }; +} + +void ParticleTransformerAK4ONNXJetTagsProducer::make_inputs( + unsigned i_jet, const reco::ParticleTransformerAK4TagInfo& taginfo) { + const auto& features = taginfo.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_); + offset = i_jet * input_sizes_[kChargedCandidates]; + 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.distminsv; // later during Run 3 after feature engineering + *(++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_); + offset = i_jet * input_sizes_[kNeutralCandidates]; + 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_); + offset = i_jet * input_sizes_[kVertices]; + 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_); + offset = i_jet * input_sizes_[kChargedCandidates4Vec]; + 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_); + offset = i_jet * input_sizes_[kNeutralCandidates4Vec]; + 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_); + offset = i_jet * input_sizes_[kVertices4Vec]; + 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..4c6caa07923d2 --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py @@ -0,0 +1,25 @@ +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) diff --git a/RecoBTag/ONNXRuntime/test/plotParTAK4.py b/RecoBTag/ONNXRuntime/test/plotParTAK4.py new file mode 100644 index 0000000000000..d50aecbcde8a7 --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/plotParTAK4.py @@ -0,0 +1,190 @@ +from __future__ import print_function +import ROOT +from DataFormats.FWLite import Handle, Events +import numpy as np +import pickle + +events_c = Events('miniFromAOD_mcRun3_withParT.root') + +handleJ = Handle("std::vector") +pu_mitigation_technique = 'PUPPI' # PUPPI +labelJ = ("slimmedJetsPuppi","","PAT") if pu_mitigation_technique == 'PUPPI' else ("slimmedJets","","PAT") + +h_disc_bvsall = ROOT.TH1F('robustpart_bvsall', ';BvsAll;', 100, -1., 1.) +h_disc_bvsl = ROOT.TH1F('robustpart_bvsl', ';BvsL;', 100, -1., 1.) +h_disc_cvsl = ROOT.TH1F('robustpart_cvsl', ';CvsL;', 100, -1., 1.) +h_disc_cvsb = ROOT.TH1F('robustpart_cvsb', ';CvsB;', 100, -1., 1.) + +h_probb = ROOT.TH1F('robustpart_probb', ';probb;', 100, -1., 1.) +h_probbb = ROOT.TH1F('robustpart_probbb', ';probbb;', 100, -1., 1.) +h_problepb = ROOT.TH1F('robustpart_problepb', ';problepb;', 100, -1., 1.) +h_probc = ROOT.TH1F('robustpart_probc', ';probc;', 100, -1., 1.) +h_probuds = ROOT.TH1F('robustpart_probuds', ';probuds;', 100, -1., 1.) +h_probuds_L = ROOT.TH1F('robustpart_probuds_L', ';probuds_L;', 100, -1., 1.) +h_probg = ROOT.TH1F('robustpart_probg', ';probg;', 100, -1., 1.) + +info = {} +info['pt'] = [] +info['eta'] = [] +info['mass'] = [] +info['probb'] = [] +info['probbb'] = [] +info['problepb'] = [] +info['probc'] = [] +info['probuds'] = [] +info['probg'] = [] +info['BvsAll'] = [] +info['BvsL'] = [] +info['CvsL'] = [] +info['CvsB'] = [] +a = 0 +for iev, event in enumerate(events_c): + a += 1 + +print(a, ' events') +for iev, event in enumerate(events_c): + event.getByLabel(labelJ, handleJ) + jets = handleJ.product() + #print(iev) + for jet in jets: + if jet.pt() < 15 or abs(jet.eta()) > 2.5: continue + #if jet.pt() < 300 or jet.pt() > 2000: continue + #if jet.mass() < 40 or jet.mass() > 200: continue + + jet_pt, jet_eta, jet_mass = jet.pt(), jet.eta(), jet.mass() + # print(jet_pt, jet_eta, jet_mass) + jet_probb = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probb") + jet_probbb = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probbb") + jet_problepb = jet.bDiscriminator("pfParticleTransformerAK4JetTags:problepb") + jet_probc = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probc") + jet_probuds = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probuds") + jet_probg = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probg") + + h_probb.Fill(jet_probb) + h_probbb.Fill(jet_probbb) + h_problepb.Fill(jet_problepb) + h_probc.Fill(jet_probc) + h_probuds.Fill(jet_probuds) + if jet.hadronFlavour() < 4: + h_probuds_L.Fill(jet_probuds) + h_probg.Fill(jet_probg) + + #print("probb", jet_probb) + #print("probbb", jet_probbb) + #print("problepb", jet_problepb) + #print("probc", jet_probc) + #print("probuds", jet_probuds) + #print("probg", jet_probg) + + jet_BvsAll = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:BvsAll") + jet_BvsL = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:BvsL") + jet_CvsL = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:CvsL") + jet_CvsB = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:CvsB") + + #print("BvsAll", jet_BvsAll) + #print("BvsL", jet_BvsL) + #print("CvsL", jet_CvsL) + #print("CvsB", jet_CvsB) + + h_disc_bvsall.Fill(jet_BvsAll) + h_disc_bvsl.Fill(jet_BvsL) + h_disc_cvsl.Fill(jet_CvsL) + h_disc_cvsb.Fill(jet_CvsB) + + info['mass'].append(jet_mass) + info['pt'].append(jet_pt) + info['eta'].append(jet_eta) + + info['probb'].append(jet_probb) + info['probbb'].append(jet_probbb) + info['problepb'].append(jet_problepb) + info['probc'].append(jet_probc) + info['probuds'].append(jet_probuds) + info['probg'].append(jet_probg) + + info['BvsAll'].append(jet_BvsAll) + info['BvsL'].append(jet_BvsL) + info['CvsL'].append(jet_CvsL) + info['CvsB'].append(jet_CvsB) + break + +with open('outputs.pkl', 'wb') as handle: + pickle.dump(info, handle) + +canv = ROOT.TCanvas() +h_disc_bvsall.Draw("HISTO") +h_disc_bvsall.SetLineColor(632) +h_disc_bvsall.SetLineStyle(10) +canv.Draw() +canv.SaveAs(f"RobustParTAK4_BvsAll{pu_mitigation_technique}.png") + +canv2 = ROOT.TCanvas() +h_disc_bvsl.Draw("HISTO") +h_disc_bvsl.SetLineColor(632) +h_disc_bvsl.SetLineStyle(10) +canv2.Draw() +canv2.SaveAs(f"RobustParTAK4_BvsL{pu_mitigation_technique}.png") + +canv3 = ROOT.TCanvas() +h_disc_cvsl.Draw("HISTO") +h_disc_cvsl.SetLineColor(632) +h_disc_cvsl.SetLineStyle(10) +canv3.Draw() +canv3.SaveAs(f"RobustParTAK4_CvsL{pu_mitigation_technique}.png") + +canv4 = ROOT.TCanvas() +h_disc_cvsb.Draw("HISTO") +h_disc_cvsb.SetLineColor(632) +h_disc_cvsb.SetLineStyle(10) +canv4.Draw() +canv4.SaveAs(f"RobustParTAK4_CvsB{pu_mitigation_technique}.png") + + +pcanv = ROOT.TCanvas() +h_probb.Draw("HISTO") +h_probb.SetLineColor(632) +h_probb.SetLineStyle(10) +pcanv.Draw() +pcanv.SaveAs(f"RobustParTAK4_probb{pu_mitigation_technique}.png") + +pcanv2 = ROOT.TCanvas() +h_probbb.Draw("HISTO") +h_probbb.SetLineColor(632) +h_probbb.SetLineStyle(10) +pcanv2.Draw() +pcanv2.SaveAs(f"RobustParTAK4_probbb{pu_mitigation_technique}.png") + +pcanv3 = ROOT.TCanvas() +h_problepb.Draw("HISTO") +h_problepb.SetLineColor(632) +h_problepb.SetLineStyle(10) +pcanv3.Draw() +pcanv3.SaveAs(f"RobustParTAK4_problepb{pu_mitigation_technique}.png") + +pcanv4 = ROOT.TCanvas() +h_probc.Draw("HISTO") +h_probc.SetLineColor(632) +h_probc.SetLineStyle(10) +pcanv4.Draw() +pcanv4.SaveAs(f"RobustParTAK4_probc{pu_mitigation_technique}.png") + +pcanv5 = ROOT.TCanvas() +h_probuds.Draw("HISTO") +h_probuds.SetLineColor(632) +h_probuds.SetLineStyle(10) +pcanv5.Draw() +pcanv5.SaveAs(f"RobustParTAK4_probuds{pu_mitigation_technique}.png") + +pcanv5L = ROOT.TCanvas() +h_probuds_L.Draw("HISTO") +h_probuds_L.SetLineColor(632) +h_probuds_L.SetLineStyle(10) +pcanv5L.Draw() +pcanv5L.SaveAs(f"RobustParTAK4_probuds_L{pu_mitigation_technique}.png") + +pcanv6 = ROOT.TCanvas() +h_probg.Draw("HISTO") +h_probg.SetLineColor(632) +h_probg.SetLineStyle(10) +pcanv6.Draw() +pcanv6.SaveAs(f"RobustParTAK4_probg{pu_mitigation_technique}.png") \ No newline at end of file diff --git a/RecoBTag/ONNXRuntime/test/step1_NANO.py b/RecoBTag/ONNXRuntime/test/step1_NANO.py new file mode 100644 index 0000000000000..d1a30275f078d --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/step1_NANO.py @@ -0,0 +1,124 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: step1 --mc --eventcontent NANOAODSIM --datatier NANOAODSIM --customise_commands=process.add_(cms.Service('InitRootHandlers', EnableIMT = cms.untracked.bool(False)));process.MessageLogger.cerr.FwkReport.reportEvery=100 --conditions 124X_mcRun3_2022_realistic_v12 --step NANO --nThreads 4 --scenario pp --era Run3 --filein file:miniFromAOD_mcRun3_withParT.root --fileout file:NanoFromMini_mcRun3.root -n -1 +import FWCore.ParameterSet.Config as cms + +from Configuration.Eras.Era_Run3_cff import Run3 + +process = cms.Process('NANO',Run3) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('PhysicsTools.NanoAOD.nano_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(-1), + output = cms.optional.untracked.allowed(cms.int32,cms.PSet) +) + +# Input source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring('file:miniFromAOD_mcRun3_withParT.root'), + secondaryFileNames = cms.untracked.vstring() +) + +process.options = cms.untracked.PSet( + FailPath = cms.untracked.vstring(), + IgnoreCompletely = cms.untracked.vstring(), + Rethrow = cms.untracked.vstring(), + SkipEvent = cms.untracked.vstring(), + accelerators = cms.untracked.vstring('*'), + allowUnscheduled = cms.obsolete.untracked.bool, + canDeleteEarly = cms.untracked.vstring(), + deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), + dumpOptions = cms.untracked.bool(False), + emptyRunLumiMode = cms.obsolete.untracked.string, + eventSetup = cms.untracked.PSet( + forceNumberOfConcurrentIOVs = cms.untracked.PSet( + allowAnyLabel_=cms.required.untracked.uint32 + ), + numberOfConcurrentIOVs = cms.untracked.uint32(0) + ), + fileMode = cms.untracked.string('FULLMERGE'), + forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), + holdsReferencesToDeleteEarly = cms.untracked.VPSet(), + makeTriggerResults = cms.obsolete.untracked.bool, + modulesToIgnoreForDeleteEarly = cms.untracked.vstring(), + numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), + numberOfConcurrentRuns = cms.untracked.uint32(1), + numberOfStreams = cms.untracked.uint32(0), + numberOfThreads = cms.untracked.uint32(1), + printDependencies = cms.untracked.bool(False), + sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, + throwIfIllegalParameter = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(False) +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('step1 nevts:-1'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Output definition + +process.NANOAODSIMoutput = cms.OutputModule("NanoAODOutputModule", + compressionAlgorithm = cms.untracked.string('LZMA'), + compressionLevel = cms.untracked.int32(9), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('NANOAODSIM'), + filterName = cms.untracked.string('') + ), + fileName = cms.untracked.string('file:NanoFromMini_mcRun3.root'), + outputCommands = process.NANOAODSIMEventContent.outputCommands +) + +# Additional output definition + +# Other statements +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_mcRun3_2022_realistic_v12', '') + +# Path and EndPath definitions +process.nanoAOD_step = cms.Path(process.nanoSequenceMC) +process.endjob_step = cms.EndPath(process.endOfProcess) +process.NANOAODSIMoutput_step = cms.EndPath(process.NANOAODSIMoutput) + +# Schedule definition +process.schedule = cms.Schedule(process.nanoAOD_step,process.endjob_step,process.NANOAODSIMoutput_step) +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) + +#Setup FWK for multithreaded +process.options.numberOfThreads = 4 +process.options.numberOfStreams = 0 + +# customisation of the process. + +# Automatic addition of the customisation function from PhysicsTools.NanoAOD.nano_cff +from PhysicsTools.NanoAOD.nano_cff import nanoAOD_customizeCommon + +#call to customisation function nanoAOD_customizeCommon imported from PhysicsTools.NanoAOD.nano_cff +process = nanoAOD_customizeCommon(process) + +# End of customisation functions + + +# Customisation from command line + +process.add_(cms.Service('InitRootHandlers', EnableIMT = cms.untracked.bool(False)));process.MessageLogger.cerr.FwkReport.reportEvery=100 +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion diff --git a/RecoBTag/ONNXRuntime/test/step1_PAT.py b/RecoBTag/ONNXRuntime/test/step1_PAT.py new file mode 100644 index 0000000000000..aaca1d87bb174 --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/step1_PAT.py @@ -0,0 +1,215 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: step1 --mc --eventcontent MINIAODSIM --datatier MINIAODSIM --conditions 124X_mcRun3_2022_realistic_v12 --step PAT --nThreads 4 --geometry DB:Extended --era Run3 --filein file:AODinput_mcRun3.root --fileout file:miniFromAOD_mcRun3.root --no_exec -n 400 +import FWCore.ParameterSet.Config as cms + +from Configuration.Eras.Era_Run3_cff import Run3 + +process = cms.Process('PAT',Run3) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('PhysicsTools.PatAlgos.slimming.metFilterPaths_cff') +process.load('Configuration.StandardSequences.PATMC_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(400), + output = cms.optional.untracked.allowed(cms.int32,cms.PSet) +) + +# Input source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring('file:/afs/cern.ch/work/a/anstein/public/CMSSW_12_6_0_patch1/src/RecoBTag/ONNXRuntime/test/AODinput_mcRun3.root'), + secondaryFileNames = cms.untracked.vstring() +) + +process.options = cms.untracked.PSet( + FailPath = cms.untracked.vstring(), + IgnoreCompletely = cms.untracked.vstring(), + Rethrow = cms.untracked.vstring(), + SkipEvent = cms.untracked.vstring(), + accelerators = cms.untracked.vstring('*'), + allowUnscheduled = cms.obsolete.untracked.bool, + canDeleteEarly = cms.untracked.vstring(), + deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), + dumpOptions = cms.untracked.bool(False), + emptyRunLumiMode = cms.obsolete.untracked.string, + eventSetup = cms.untracked.PSet( + forceNumberOfConcurrentIOVs = cms.untracked.PSet( + allowAnyLabel_=cms.required.untracked.uint32 + ), + numberOfConcurrentIOVs = cms.untracked.uint32(0) + ), + fileMode = cms.untracked.string('FULLMERGE'), + forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), + holdsReferencesToDeleteEarly = cms.untracked.VPSet(), + makeTriggerResults = cms.obsolete.untracked.bool, + modulesToIgnoreForDeleteEarly = cms.untracked.vstring(), + numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), + numberOfConcurrentRuns = cms.untracked.uint32(1), + numberOfStreams = cms.untracked.uint32(0), + numberOfThreads = cms.untracked.uint32(4), + printDependencies = cms.untracked.bool(False), + sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, + throwIfIllegalParameter = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(True) + #wantSummary = cms.untracked.bool(False) +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('step1 nevts:4000'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +process.MessageLogger.cerr.FwkReport.reportEvery=10 + +# Output definition + +process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule", + compressionAlgorithm = cms.untracked.string('LZMA'), + compressionLevel = cms.untracked.int32(4), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('MINIAODSIM'), + filterName = cms.untracked.string('') + ), + dropMetaData = cms.untracked.string('ALL'), + eventAutoFlushCompressedSize = cms.untracked.int32(-900), + fastCloning = cms.untracked.bool(False), + #fileName = cms.untracked.string('file:miniFromAOD_mcRun3.root'), + fileName = cms.untracked.string('file:miniFromAOD_mcRun3_withParT.root'), + outputCommands = process.MINIAODSIMEventContent.outputCommands, + overrideBranchesSplitLevel = cms.untracked.VPSet( + cms.untracked.PSet( + branch = cms.untracked.string('patPackedCandidates_packedPFCandidates__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoGenParticles_prunedGenParticles__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patTriggerObjectStandAlones_slimmedPatTrigger__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patPackedGenParticles_packedGenParticles__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patJets_slimmedJets__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVertices__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVerticesWithBS__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoCaloClusters_reducedEgamma_reducedESClusters_*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEBRecHits_*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEERecHits_*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoGenJets_slimmedGenJets__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patJets_slimmedJetsPuppi__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedESRecHits_*'), + splitLevel = cms.untracked.int32(99) + ) + ), + overrideInputFileSplitLevels = cms.untracked.bool(True), + splitLevel = cms.untracked.int32(0) +) + +# Additional output definition + +# Other statements +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_mcRun3_2022_realistic_v12', '') + +# Path and EndPath definitions +process.Flag_BadChargedCandidateFilter = cms.Path(process.BadChargedCandidateFilter) +process.Flag_BadChargedCandidateSummer16Filter = cms.Path(process.BadChargedCandidateSummer16Filter) +process.Flag_BadPFMuonDzFilter = cms.Path(process.BadPFMuonDzFilter) +process.Flag_BadPFMuonFilter = cms.Path(process.BadPFMuonFilter) +process.Flag_BadPFMuonSummer16Filter = cms.Path(process.BadPFMuonSummer16Filter) +process.Flag_CSCTightHalo2015Filter = cms.Path(process.CSCTightHalo2015Filter) +process.Flag_CSCTightHaloFilter = cms.Path(process.CSCTightHaloFilter) +process.Flag_CSCTightHaloTrkMuUnvetoFilter = cms.Path(process.CSCTightHaloTrkMuUnvetoFilter) +process.Flag_EcalDeadCellBoundaryEnergyFilter = cms.Path(process.EcalDeadCellBoundaryEnergyFilter) +process.Flag_EcalDeadCellTriggerPrimitiveFilter = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter) +process.Flag_HBHENoiseFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseFilter) +process.Flag_HBHENoiseIsoFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseIsoFilter) +process.Flag_HcalStripHaloFilter = cms.Path(process.HcalStripHaloFilter) +process.Flag_METFilters = cms.Path(process.metFilters) +process.Flag_chargedHadronTrackResolutionFilter = cms.Path(process.chargedHadronTrackResolutionFilter) +process.Flag_ecalBadCalibFilter = cms.Path(process.ecalBadCalibFilter) +process.Flag_ecalLaserCorrFilter = cms.Path(process.ecalLaserCorrFilter) +process.Flag_eeBadScFilter = cms.Path(process.eeBadScFilter) +process.Flag_globalSuperTightHalo2016Filter = cms.Path(process.globalSuperTightHalo2016Filter) +process.Flag_globalTightHalo2016Filter = cms.Path(process.globalTightHalo2016Filter) +process.Flag_goodVertices = cms.Path(process.primaryVertexFilter) +process.Flag_hcalLaserEventFilter = cms.Path(process.hcalLaserEventFilter) +process.Flag_hfNoisyHitsFilter = cms.Path(process.hfNoisyHitsFilter) +process.Flag_muonBadTrackFilter = cms.Path(process.muonBadTrackFilter) +process.Flag_trackingFailureFilter = cms.Path(process.goodVertices+process.trackingFailureFilter) +process.Flag_trkPOGFilters = cms.Path(process.trkPOGFilters) +process.Flag_trkPOG_logErrorTooManyClusters = cms.Path(~process.logErrorTooManyClusters) +process.Flag_trkPOG_manystripclus53X = cms.Path(~process.manystripclus53X) +process.Flag_trkPOG_toomanystripclus53X = cms.Path(~process.toomanystripclus53X) +process.endjob_step = cms.EndPath(process.endOfProcess) +process.MINIAODSIMoutput_step = cms.EndPath(process.MINIAODSIMoutput) + +# Schedule definition +process.schedule = cms.Schedule(process.Flag_HBHENoiseFilter,process.Flag_HBHENoiseIsoFilter,process.Flag_CSCTightHaloFilter,process.Flag_CSCTightHaloTrkMuUnvetoFilter,process.Flag_CSCTightHalo2015Filter,process.Flag_globalTightHalo2016Filter,process.Flag_globalSuperTightHalo2016Filter,process.Flag_HcalStripHaloFilter,process.Flag_hcalLaserEventFilter,process.Flag_EcalDeadCellTriggerPrimitiveFilter,process.Flag_EcalDeadCellBoundaryEnergyFilter,process.Flag_ecalBadCalibFilter,process.Flag_goodVertices,process.Flag_eeBadScFilter,process.Flag_ecalLaserCorrFilter,process.Flag_trkPOGFilters,process.Flag_chargedHadronTrackResolutionFilter,process.Flag_muonBadTrackFilter,process.Flag_BadChargedCandidateFilter,process.Flag_BadPFMuonFilter,process.Flag_BadPFMuonDzFilter,process.Flag_hfNoisyHitsFilter,process.Flag_BadChargedCandidateSummer16Filter,process.Flag_BadPFMuonSummer16Filter,process.Flag_trkPOG_manystripclus53X,process.Flag_trkPOG_toomanystripclus53X,process.Flag_trkPOG_logErrorTooManyClusters,process.Flag_METFilters,process.endjob_step,process.MINIAODSIMoutput_step) +process.schedule.associate(process.patTask) +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) + +#Setup FWK for multithreaded +process.options.numberOfThreads = 4 +process.options.numberOfStreams = 0 + +# customisation of the process. + +# Automatic addition of the customisation function from PhysicsTools.PatAlgos.slimming.miniAOD_tools +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC + +#call to customisation function miniAOD_customizeAllMC imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools +process = miniAOD_customizeAllMC(process) + +# End of customisation functions + +# Customisation from command line + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion \ No newline at end of file From 598ec0a14a9fc3a394fcffb0ee9d82cd4520d838 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Thu, 30 Mar 2023 17:12:33 +0200 Subject: [PATCH 02/17] ParT PUPPI Run 3 WIP --- .../PatAlgos/python/tools/jetTools.py | 8 +- .../ParticleTransformerAK4TagInfoProducer.cc | 27 +++---- ...rticleTransformerAK4ONNXJetTagsProducer.cc | 26 +++---- RecoBTag/ONNXRuntime/test/testONNXsess.py | 73 +++++++++++++++++++ 4 files changed, 104 insertions(+), 30 deletions(-) create mode 100644 RecoBTag/ONNXRuntime/test/testONNXsess.py diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 0c32d01caf0b8..040166662727e 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -629,11 +629,11 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou # use right input tags when running with RECO PF candidates, which actually # depens of wether jets were slimmed or not (check for s/S-limmed in name) if not ('limmed' in jetSource.value()): - puppi_value_map = cms.InputTag("puppi") - vertex_associator = cms.InputTag("primaryVertexAssociation","original") + puppi_value_map = cms.InputTag("puppi") + vertex_associator = cms.InputTag("primaryVertexAssociation","original") else: - puppi_value_map = cms.InputTag("") - vertex_associator = cms.InputTag("") + puppi_value_map = cms.InputTag("") + vertex_associator = cms.InputTag("") addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, btag.pfDeepFlavourTagInfos.clone( jets = jetSource, diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index 441a92ba5f0d5..405eeb8ead9a3 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -85,22 +85,23 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { edm::EDGetTokenT> pvas_token_; edm::EDGetTokenT> candidateToken_; edm::ESGetToken track_builder_token_; +/* edm::ESGetToken calib2d_token_; edm::ESGetToken calib3d_token_; - +*/ bool use_puppi_value_map_; bool use_pvasq_value_map_; bool fallback_puppi_weight_; bool fallback_vertex_association_; - +/* //TrackProbability void checkEventSetup(const edm::EventSetup& iSetup); std::unique_ptr probabilityEstimator_; bool compute_probabilities_; unsigned long long calibrationCacheId2D_; unsigned long long calibrationCacheId3D_; - +*/ const double min_jet_pt_; const double max_jet_eta_; }; @@ -119,7 +120,7 @@ ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(con use_pvasq_value_map_(false), fallback_puppi_weight_(iConfig.getParameter("fallback_puppi_weight")), fallback_vertex_association_(iConfig.getParameter("fallback_vertex_association")), - compute_probabilities_(iConfig.getParameter("compute_probabilities")), + //compute_probabilities_(iConfig.getParameter("compute_probabilities")), min_jet_pt_(iConfig.getParameter("min_jet_pt")), max_jet_eta_(iConfig.getParameter("max_jet_eta")) { produces(); @@ -136,10 +137,12 @@ ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(con pvas_token_ = consumes>(pvas_tag); use_pvasq_value_map_ = true; } + /* if (compute_probabilities_) { calib2d_token_ = esConsumes(); calib3d_token_ = esConsumes(); } + */ } ParticleTransformerAK4TagInfoProducer::~ParticleTransformerAK4TagInfoProducer() {} @@ -158,7 +161,7 @@ void ParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationD desc.add("vertex_associator", edm::InputTag("primaryVertexAssociation", "original")); desc.add("fallback_puppi_weight", false); desc.add("fallback_vertex_association", false); - desc.add("compute_probabilities", false); + //desc.add("compute_probabilities", false); desc.add("min_jet_pt", 15.0); desc.add("max_jet_eta", 2.5); descriptions.add("pfParticleTransformerAK4TagInfos", desc); @@ -166,9 +169,10 @@ void ParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationD void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { auto output_tag_infos = std::make_unique(); + /* if (compute_probabilities_) checkEventSetup(iSetup); - + */ edm::Handle> jets; iEvent.getByToken(jet_token_, jets); @@ -202,9 +206,6 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed edm::ESHandle track_builder = iSetup.getHandle(track_builder_token_); - //std::vector selectedTracks; - //std::vector masses; - for (std::size_t jet_n = 0; jet_n < jets->size(); jet_n++) { // create data containing structure btagbtvdeep::ParticleTransformerAK4Features features; @@ -325,14 +326,14 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed 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, @@ -402,7 +403,7 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed iEvent.put(std::move(output_tag_infos)); } - +/* void ParticleTransformerAK4TagInfoProducer::checkEventSetup(const edm::EventSetup& iSetup) { using namespace edm; using namespace edm::eventsetup; @@ -422,6 +423,6 @@ void ParticleTransformerAK4TagInfoProducer::checkEventSetup(const edm::EventSetu calibrationCacheId3D_ = cacheId3D; calibrationCacheId2D_ = cacheId2D; } - +*/ //define this as a plug-in DEFINE_FWK_MODULE(ParticleTransformerAK4TagInfoProducer); \ No newline at end of file diff --git a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc index ea8b5222fcdac..7a66a8b70e2b5 100644 --- a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -50,7 +50,7 @@ class ParticleTransformerAK4ONNXJetTagsProducer : public edm::stream::EDProducer kVertices4Vec = 5 }; unsigned n_cpf_; - constexpr static unsigned n_features_cpf_ = 17; + 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; @@ -88,7 +88,7 @@ void ParticleTransformerAK4ONNXJetTagsProducer::fillDescriptions(edm::Configurat { "input_1", "input_2", "input_3", "input_4", "input_5", "input_6" }); - desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/RobustParTAK4/Run2/V00/RobustParTAK4_Run2.onnx")); + desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/RobustParTAK4/PUPPI/V00/DJT.onnx")); desc.add>("output_names", {"softmax"}); desc.add>( "flav_names", std::vector{"probb", "probbb", "problepb", "probc", "probuds", "probg"}); @@ -171,16 +171,16 @@ void ParticleTransformerAK4ONNXJetTagsProducer::get_input_sizes(edm::Handle', data) +#print('input ->', data1, data2, data3, data4, data5, data6) +print('output ->', outputs) + + + +# data1 = np.ones((1, 25, 16)).astype(np.float32) +# data2 = np.ones((1, 25, 8)).astype(np.float32) +# data3 = np.ones((1, 4, 14)).astype(np.float32) +# data4 = np.ones((1, 25, 4)).astype(np.float32) +# data5 = np.ones((1, 25, 4)).astype(np.float32) +# data6 = np.ones((1, 4, 4)).astype(np.float32) +# create inference session using ort.InferenceSessio +# create inference session using ort.InferenceSession from a given model +ort_sess = ort.InferenceSession('/afs/cern.ch/work/a/anstein/private/ParTPUPPI/CMSSW_13_1_0_pre2/src/RecoBTag/Combined/data/RobustParTAK4/PUPPI/V00/DJT_build4v.onnx', providers=[ + #'CUDAExecutionProvider', + 'CPUExecutionProvider']) + +# run inference +outputs = ort_sess.run(None, {'input_1': data1, + 'input_2': data2, + 'input_3': data3, + 'input_4': data4, + 'input_5': data5, + 'input_6': data6})[0] + +# print input and output +# print('input ->', data) +# print('input ->', data1, data2, data3, data4, data5, data6) +print('output ->', outputs) \ No newline at end of file From d2366250be91a647a4930e180e9e924646e5b387 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Tue, 4 Apr 2023 15:10:23 +0200 Subject: [PATCH 03/17] paths to new models (122X training) --- .../ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc | 5 ++--- .../plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc index 10dacfcd5e819..d140d1f772605 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc @@ -79,8 +79,7 @@ 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 +109,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 index 7a66a8b70e2b5..462510da0e077 100644 --- a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -88,7 +88,7 @@ void ParticleTransformerAK4ONNXJetTagsProducer::fillDescriptions(edm::Configurat { "input_1", "input_2", "input_3", "input_4", "input_5", "input_6" }); - desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/RobustParTAK4/PUPPI/V00/DJT.onnx")); + desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/RobustParTAK4/PUPPI/V00/ParTAK4.onnx")); desc.add>("output_names", {"softmax"}); desc.add>( "flav_names", std::vector{"probb", "probbb", "problepb", "probc", "probuds", "probg"}); From 71b0f0451bae8ec73b3596ff3820b7a4887f5031 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Tue, 4 Apr 2023 15:36:32 +0200 Subject: [PATCH 04/17] code-checks, code-format --- .../interface/ChargedCandidateConverter.h | 20 ++--- .../interface/NeutralCandidateConverter.h | 4 +- .../FeatureTools/interface/deep_helpers.h | 3 +- .../ParticleTransformerAK4TagInfoProducer.cc | 17 ++-- RecoBTag/FeatureTools/src/deep_helpers.cc | 4 +- .../plugins/DeepFlavourONNXJetTagsProducer.cc | 3 +- ...rticleTransformerAK4ONNXJetTagsProducer.cc | 88 +++++++++---------- 7 files changed, 67 insertions(+), 72 deletions(-) diff --git a/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h b/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h index 21dcb466d1038..a437cde598898 100644 --- a/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h +++ b/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h @@ -53,17 +53,17 @@ namespace btagbtvdeep { 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; + 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(); + 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, diff --git a/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h b/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h index 1ede64bac631f..4253781eb2635 100644 --- a/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h +++ b/RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h @@ -46,8 +46,8 @@ namespace btagbtvdeep { 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.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(); diff --git a/RecoBTag/FeatureTools/interface/deep_helpers.h b/RecoBTag/FeatureTools/interface/deep_helpers.h index 9802343b50128..d0f50b63efa5b 100644 --- a/RecoBTag/FeatureTools/interface/deep_helpers.h +++ b/RecoBTag/FeatureTools/interface/deep_helpers.h @@ -83,8 +83,7 @@ namespace btagbtvdeep { 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); + 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); diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index 405eeb8ead9a3..a1501d6178ab4 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -68,7 +68,7 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { 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 {} @@ -85,7 +85,7 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { edm::EDGetTokenT> pvas_token_; edm::EDGetTokenT> candidateToken_; edm::ESGetToken track_builder_token_; -/* + /* edm::ESGetToken calib2d_token_; edm::ESGetToken calib3d_token_; */ @@ -94,7 +94,7 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { bool fallback_puppi_weight_; bool fallback_vertex_association_; -/* + /* //TrackProbability void checkEventSetup(const edm::EventSetup& iSetup); std::unique_ptr probabilityEstimator_; @@ -212,12 +212,14 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed // reco jet reference (use as much as possible) const auto& jet = jets->at(jet_n); - if(jet.pt() < 15.0){continue;} + if (jet.pt() < 15.0) { + continue; + } // 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); - + math::XYZVector jet_dir = jet.momentum().Unit(); GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz()); @@ -326,14 +328,13 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed auto& c_pf_features = features.c_pf_features.at(entry); // fill feature structure if (packed_cand) { - - if (packed_cand->hasTrackDetails()){ + 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, diff --git a/RecoBTag/FeatureTools/src/deep_helpers.cc b/RecoBTag/FeatureTools/src/deep_helpers.cc index 454defc859f7c..76b443542b334 100644 --- a/RecoBTag/FeatureTools/src/deep_helpers.cc +++ b/RecoBTag/FeatureTools/src/deep_helpers.cc @@ -93,7 +93,7 @@ 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; @@ -143,7 +143,7 @@ namespace btagbtvdeep { } 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 d140d1f772605..b958dc84629c0 100644 --- a/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc @@ -79,7 +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/DeepFlavourV04_12X_training/DeepJet_Run3_122X.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"}); diff --git a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc index 462510da0e077..c2dc8e6b75319 100644 --- a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -75,7 +75,6 @@ ParticleTransformerAK4ONNXJetTagsProducer::ParticleTransformerAK4ONNXJetTagsProd for (const auto& flav_name : flav_names_) { produces(flav_name); } - } ParticleTransformerAK4ONNXJetTagsProducer::~ParticleTransformerAK4ONNXJetTagsProducer() {} @@ -84,11 +83,9 @@ void ParticleTransformerAK4ONNXJetTagsProducer::fillDescriptions(edm::Configurat // 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/ParTAK4.onnx")); + 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/ParTAK4.onnx")); desc.add>("output_names", {"softmax"}); desc.add>( "flav_names", std::vector{"probb", "probbb", "problepb", "probc", "probuds", "probg"}); @@ -116,7 +113,7 @@ void ParticleTransformerAK4ONNXJetTagsProducer::produce(edm::Event& iEvent, cons output_tags.emplace_back(std::make_unique(ref2prod)); } get_input_sizes(tag_infos); - + // init data storage data_.clear(); for (const auto& len : input_sizes_) { @@ -128,14 +125,12 @@ void ParticleTransformerAK4ONNXJetTagsProducer::produce(edm::Event& iEvent, cons make_inputs(jet_n, taginfo); } // run prediction with dynamic batch size per event - input_shapes_ = { - {(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_features_cpf_}, - {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_features_npf_}, - {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_features_sv_}, - {(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_pairwise_features_cpf_}, - {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_pairwise_features_npf_}, - {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_pairwise_features_sv_} - }; + input_shapes_ = {{(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_features_cpf_}, + {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_features_npf_}, + {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_features_sv_}, + {(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_pairwise_features_cpf_}, + {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_pairwise_features_npf_}, + {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_pairwise_features_sv_}}; auto outputs = globalCache()->run(input_names_, data_, input_shapes_, output_names_, tag_infos->size())[0]; assert(outputs.size() == flav_names_.size() * tag_infos->size()); @@ -162,40 +157,39 @@ void ParticleTransformerAK4ONNXJetTagsProducer::produce(edm::Event& iEvent, cons } } -void ParticleTransformerAK4ONNXJetTagsProducer::get_input_sizes(edm::Handle tag_infos){ - for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& taginfo = (*tag_infos)[jet_n]; - 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(); - - if (jet_n == 0){ - 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); - } - else{ - n_cpf_ = std::max(n_cpf_, n_cpf); - n_npf_ = std::max(n_npf_, n_npf); - n_sv_ = std::max(n_sv_, 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_, - }; +void ParticleTransformerAK4ONNXJetTagsProducer::get_input_sizes(edm::Handle tag_infos) { + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& taginfo = (*tag_infos)[jet_n]; + 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(); + + if (jet_n == 0) { + 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); + } else { + n_cpf_ = std::max(n_cpf_, n_cpf); + n_npf_ = std::max(n_npf_, n_npf); + n_sv_ = std::max(n_sv_, 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_, + }; } -void ParticleTransformerAK4ONNXJetTagsProducer::make_inputs( - unsigned i_jet, const reco::ParticleTransformerAK4TagInfo& taginfo) { +void ParticleTransformerAK4ONNXJetTagsProducer::make_inputs(unsigned i_jet, + const reco::ParticleTransformerAK4TagInfo& taginfo) { const auto& features = taginfo.features(); float* ptr = nullptr; const float* start = nullptr; From 98c040eb097725f6f292724c4ab5bea6055f4d46 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Tue, 4 Apr 2023 21:12:50 +0200 Subject: [PATCH 05/17] cleanup --- .../ParticleTransformerAK4TagInfoProducer.cc | 44 ------------------- 1 file changed, 44 deletions(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index a1501d6178ab4..77d2616e6374b 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -85,23 +85,11 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { edm::EDGetTokenT> pvas_token_; edm::EDGetTokenT> candidateToken_; edm::ESGetToken track_builder_token_; - /* - edm::ESGetToken calib2d_token_; - edm::ESGetToken calib3d_token_; -*/ bool use_puppi_value_map_; bool use_pvasq_value_map_; bool fallback_puppi_weight_; bool fallback_vertex_association_; - /* - //TrackProbability - void checkEventSetup(const edm::EventSetup& iSetup); - std::unique_ptr probabilityEstimator_; - bool compute_probabilities_; - unsigned long long calibrationCacheId2D_; - unsigned long long calibrationCacheId3D_; -*/ const double min_jet_pt_; const double max_jet_eta_; }; @@ -120,7 +108,6 @@ ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(con use_pvasq_value_map_(false), fallback_puppi_weight_(iConfig.getParameter("fallback_puppi_weight")), fallback_vertex_association_(iConfig.getParameter("fallback_vertex_association")), - //compute_probabilities_(iConfig.getParameter("compute_probabilities")), min_jet_pt_(iConfig.getParameter("min_jet_pt")), max_jet_eta_(iConfig.getParameter("max_jet_eta")) { produces(); @@ -137,12 +124,6 @@ ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(con pvas_token_ = consumes>(pvas_tag); use_pvasq_value_map_ = true; } - /* - if (compute_probabilities_) { - calib2d_token_ = esConsumes(); - calib3d_token_ = esConsumes(); - } - */ } ParticleTransformerAK4TagInfoProducer::~ParticleTransformerAK4TagInfoProducer() {} @@ -161,7 +142,6 @@ void ParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationD desc.add("vertex_associator", edm::InputTag("primaryVertexAssociation", "original")); desc.add("fallback_puppi_weight", false); desc.add("fallback_vertex_association", false); - //desc.add("compute_probabilities", false); desc.add("min_jet_pt", 15.0); desc.add("max_jet_eta", 2.5); descriptions.add("pfParticleTransformerAK4TagInfos", desc); @@ -169,10 +149,6 @@ void ParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationD void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { auto output_tag_infos = std::make_unique(); - /* - if (compute_probabilities_) - checkEventSetup(iSetup); - */ edm::Handle> jets; iEvent.getByToken(jet_token_, jets); @@ -404,26 +380,6 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed iEvent.put(std::move(output_tag_infos)); } -/* -void ParticleTransformerAK4TagInfoProducer::checkEventSetup(const edm::EventSetup& iSetup) { - using namespace edm; - using namespace edm::eventsetup; - - const EventSetupRecord& re2D = iSetup.get(); - const EventSetupRecord& re3D = iSetup.get(); - unsigned long long cacheId2D = re2D.cacheIdentifier(); - unsigned long long cacheId3D = re3D.cacheIdentifier(); - if (cacheId2D != calibrationCacheId2D_ || cacheId3D != calibrationCacheId3D_) //Calibration changed - { - ESHandle calib2DHandle = iSetup.getHandle(calib2d_token_); - ESHandle calib3DHandle = iSetup.getHandle(calib3d_token_); - probabilityEstimator_ = - std::make_unique(calib3DHandle.product(), calib2DHandle.product()); - } - calibrationCacheId3D_ = cacheId3D; - calibrationCacheId2D_ = cacheId2D; -} -*/ //define this as a plug-in DEFINE_FWK_MODULE(ParticleTransformerAK4TagInfoProducer); \ No newline at end of file From ce6bb4f505c503deca01e0958fc6911d4724ecea Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Tue, 4 Apr 2023 21:17:14 +0200 Subject: [PATCH 06/17] cleanup --- .../plugins/ParticleTransformerAK4TagInfoProducer.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index 77d2616e6374b..db3e3ae685114 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -382,4 +382,4 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed } //define this as a plug-in -DEFINE_FWK_MODULE(ParticleTransformerAK4TagInfoProducer); \ No newline at end of file +DEFINE_FWK_MODULE(ParticleTransformerAK4TagInfoProducer); From 07aac71ca553cb346786bd4b98375e9158db20b9 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Tue, 4 Apr 2023 21:21:55 +0200 Subject: [PATCH 07/17] rm tests --- RecoBTag/ONNXRuntime/test/plotParTAK4.py | 190 ------------------- RecoBTag/ONNXRuntime/test/step1_NANO.py | 124 ------------- RecoBTag/ONNXRuntime/test/step1_PAT.py | 215 ---------------------- RecoBTag/ONNXRuntime/test/testONNXsess.py | 73 -------- 4 files changed, 602 deletions(-) delete mode 100644 RecoBTag/ONNXRuntime/test/plotParTAK4.py delete mode 100644 RecoBTag/ONNXRuntime/test/step1_NANO.py delete mode 100644 RecoBTag/ONNXRuntime/test/step1_PAT.py delete mode 100644 RecoBTag/ONNXRuntime/test/testONNXsess.py diff --git a/RecoBTag/ONNXRuntime/test/plotParTAK4.py b/RecoBTag/ONNXRuntime/test/plotParTAK4.py deleted file mode 100644 index d50aecbcde8a7..0000000000000 --- a/RecoBTag/ONNXRuntime/test/plotParTAK4.py +++ /dev/null @@ -1,190 +0,0 @@ -from __future__ import print_function -import ROOT -from DataFormats.FWLite import Handle, Events -import numpy as np -import pickle - -events_c = Events('miniFromAOD_mcRun3_withParT.root') - -handleJ = Handle("std::vector") -pu_mitigation_technique = 'PUPPI' # PUPPI -labelJ = ("slimmedJetsPuppi","","PAT") if pu_mitigation_technique == 'PUPPI' else ("slimmedJets","","PAT") - -h_disc_bvsall = ROOT.TH1F('robustpart_bvsall', ';BvsAll;', 100, -1., 1.) -h_disc_bvsl = ROOT.TH1F('robustpart_bvsl', ';BvsL;', 100, -1., 1.) -h_disc_cvsl = ROOT.TH1F('robustpart_cvsl', ';CvsL;', 100, -1., 1.) -h_disc_cvsb = ROOT.TH1F('robustpart_cvsb', ';CvsB;', 100, -1., 1.) - -h_probb = ROOT.TH1F('robustpart_probb', ';probb;', 100, -1., 1.) -h_probbb = ROOT.TH1F('robustpart_probbb', ';probbb;', 100, -1., 1.) -h_problepb = ROOT.TH1F('robustpart_problepb', ';problepb;', 100, -1., 1.) -h_probc = ROOT.TH1F('robustpart_probc', ';probc;', 100, -1., 1.) -h_probuds = ROOT.TH1F('robustpart_probuds', ';probuds;', 100, -1., 1.) -h_probuds_L = ROOT.TH1F('robustpart_probuds_L', ';probuds_L;', 100, -1., 1.) -h_probg = ROOT.TH1F('robustpart_probg', ';probg;', 100, -1., 1.) - -info = {} -info['pt'] = [] -info['eta'] = [] -info['mass'] = [] -info['probb'] = [] -info['probbb'] = [] -info['problepb'] = [] -info['probc'] = [] -info['probuds'] = [] -info['probg'] = [] -info['BvsAll'] = [] -info['BvsL'] = [] -info['CvsL'] = [] -info['CvsB'] = [] -a = 0 -for iev, event in enumerate(events_c): - a += 1 - -print(a, ' events') -for iev, event in enumerate(events_c): - event.getByLabel(labelJ, handleJ) - jets = handleJ.product() - #print(iev) - for jet in jets: - if jet.pt() < 15 or abs(jet.eta()) > 2.5: continue - #if jet.pt() < 300 or jet.pt() > 2000: continue - #if jet.mass() < 40 or jet.mass() > 200: continue - - jet_pt, jet_eta, jet_mass = jet.pt(), jet.eta(), jet.mass() - # print(jet_pt, jet_eta, jet_mass) - jet_probb = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probb") - jet_probbb = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probbb") - jet_problepb = jet.bDiscriminator("pfParticleTransformerAK4JetTags:problepb") - jet_probc = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probc") - jet_probuds = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probuds") - jet_probg = jet.bDiscriminator("pfParticleTransformerAK4JetTags:probg") - - h_probb.Fill(jet_probb) - h_probbb.Fill(jet_probbb) - h_problepb.Fill(jet_problepb) - h_probc.Fill(jet_probc) - h_probuds.Fill(jet_probuds) - if jet.hadronFlavour() < 4: - h_probuds_L.Fill(jet_probuds) - h_probg.Fill(jet_probg) - - #print("probb", jet_probb) - #print("probbb", jet_probbb) - #print("problepb", jet_problepb) - #print("probc", jet_probc) - #print("probuds", jet_probuds) - #print("probg", jet_probg) - - jet_BvsAll = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:BvsAll") - jet_BvsL = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:BvsL") - jet_CvsL = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:CvsL") - jet_CvsB = jet.bDiscriminator("pfParticleTransformerAK4DiscriminatorsJetTags:CvsB") - - #print("BvsAll", jet_BvsAll) - #print("BvsL", jet_BvsL) - #print("CvsL", jet_CvsL) - #print("CvsB", jet_CvsB) - - h_disc_bvsall.Fill(jet_BvsAll) - h_disc_bvsl.Fill(jet_BvsL) - h_disc_cvsl.Fill(jet_CvsL) - h_disc_cvsb.Fill(jet_CvsB) - - info['mass'].append(jet_mass) - info['pt'].append(jet_pt) - info['eta'].append(jet_eta) - - info['probb'].append(jet_probb) - info['probbb'].append(jet_probbb) - info['problepb'].append(jet_problepb) - info['probc'].append(jet_probc) - info['probuds'].append(jet_probuds) - info['probg'].append(jet_probg) - - info['BvsAll'].append(jet_BvsAll) - info['BvsL'].append(jet_BvsL) - info['CvsL'].append(jet_CvsL) - info['CvsB'].append(jet_CvsB) - break - -with open('outputs.pkl', 'wb') as handle: - pickle.dump(info, handle) - -canv = ROOT.TCanvas() -h_disc_bvsall.Draw("HISTO") -h_disc_bvsall.SetLineColor(632) -h_disc_bvsall.SetLineStyle(10) -canv.Draw() -canv.SaveAs(f"RobustParTAK4_BvsAll{pu_mitigation_technique}.png") - -canv2 = ROOT.TCanvas() -h_disc_bvsl.Draw("HISTO") -h_disc_bvsl.SetLineColor(632) -h_disc_bvsl.SetLineStyle(10) -canv2.Draw() -canv2.SaveAs(f"RobustParTAK4_BvsL{pu_mitigation_technique}.png") - -canv3 = ROOT.TCanvas() -h_disc_cvsl.Draw("HISTO") -h_disc_cvsl.SetLineColor(632) -h_disc_cvsl.SetLineStyle(10) -canv3.Draw() -canv3.SaveAs(f"RobustParTAK4_CvsL{pu_mitigation_technique}.png") - -canv4 = ROOT.TCanvas() -h_disc_cvsb.Draw("HISTO") -h_disc_cvsb.SetLineColor(632) -h_disc_cvsb.SetLineStyle(10) -canv4.Draw() -canv4.SaveAs(f"RobustParTAK4_CvsB{pu_mitigation_technique}.png") - - -pcanv = ROOT.TCanvas() -h_probb.Draw("HISTO") -h_probb.SetLineColor(632) -h_probb.SetLineStyle(10) -pcanv.Draw() -pcanv.SaveAs(f"RobustParTAK4_probb{pu_mitigation_technique}.png") - -pcanv2 = ROOT.TCanvas() -h_probbb.Draw("HISTO") -h_probbb.SetLineColor(632) -h_probbb.SetLineStyle(10) -pcanv2.Draw() -pcanv2.SaveAs(f"RobustParTAK4_probbb{pu_mitigation_technique}.png") - -pcanv3 = ROOT.TCanvas() -h_problepb.Draw("HISTO") -h_problepb.SetLineColor(632) -h_problepb.SetLineStyle(10) -pcanv3.Draw() -pcanv3.SaveAs(f"RobustParTAK4_problepb{pu_mitigation_technique}.png") - -pcanv4 = ROOT.TCanvas() -h_probc.Draw("HISTO") -h_probc.SetLineColor(632) -h_probc.SetLineStyle(10) -pcanv4.Draw() -pcanv4.SaveAs(f"RobustParTAK4_probc{pu_mitigation_technique}.png") - -pcanv5 = ROOT.TCanvas() -h_probuds.Draw("HISTO") -h_probuds.SetLineColor(632) -h_probuds.SetLineStyle(10) -pcanv5.Draw() -pcanv5.SaveAs(f"RobustParTAK4_probuds{pu_mitigation_technique}.png") - -pcanv5L = ROOT.TCanvas() -h_probuds_L.Draw("HISTO") -h_probuds_L.SetLineColor(632) -h_probuds_L.SetLineStyle(10) -pcanv5L.Draw() -pcanv5L.SaveAs(f"RobustParTAK4_probuds_L{pu_mitigation_technique}.png") - -pcanv6 = ROOT.TCanvas() -h_probg.Draw("HISTO") -h_probg.SetLineColor(632) -h_probg.SetLineStyle(10) -pcanv6.Draw() -pcanv6.SaveAs(f"RobustParTAK4_probg{pu_mitigation_technique}.png") \ No newline at end of file diff --git a/RecoBTag/ONNXRuntime/test/step1_NANO.py b/RecoBTag/ONNXRuntime/test/step1_NANO.py deleted file mode 100644 index d1a30275f078d..0000000000000 --- a/RecoBTag/ONNXRuntime/test/step1_NANO.py +++ /dev/null @@ -1,124 +0,0 @@ -# Auto generated configuration file -# using: -# Revision: 1.19 -# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v -# with command line options: step1 --mc --eventcontent NANOAODSIM --datatier NANOAODSIM --customise_commands=process.add_(cms.Service('InitRootHandlers', EnableIMT = cms.untracked.bool(False)));process.MessageLogger.cerr.FwkReport.reportEvery=100 --conditions 124X_mcRun3_2022_realistic_v12 --step NANO --nThreads 4 --scenario pp --era Run3 --filein file:miniFromAOD_mcRun3_withParT.root --fileout file:NanoFromMini_mcRun3.root -n -1 -import FWCore.ParameterSet.Config as cms - -from Configuration.Eras.Era_Run3_cff import Run3 - -process = cms.Process('NANO',Run3) - -# import of standard configurations -process.load('Configuration.StandardSequences.Services_cff') -process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') -process.load('FWCore.MessageService.MessageLogger_cfi') -process.load('Configuration.EventContent.EventContent_cff') -process.load('SimGeneral.MixingModule.mixNoPU_cfi') -process.load('Configuration.StandardSequences.GeometryRecoDB_cff') -process.load('Configuration.StandardSequences.MagneticField_cff') -process.load('PhysicsTools.NanoAOD.nano_cff') -process.load('Configuration.StandardSequences.EndOfProcess_cff') -process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') - -process.maxEvents = cms.untracked.PSet( - input = cms.untracked.int32(-1), - output = cms.optional.untracked.allowed(cms.int32,cms.PSet) -) - -# Input source -process.source = cms.Source("PoolSource", - fileNames = cms.untracked.vstring('file:miniFromAOD_mcRun3_withParT.root'), - secondaryFileNames = cms.untracked.vstring() -) - -process.options = cms.untracked.PSet( - FailPath = cms.untracked.vstring(), - IgnoreCompletely = cms.untracked.vstring(), - Rethrow = cms.untracked.vstring(), - SkipEvent = cms.untracked.vstring(), - accelerators = cms.untracked.vstring('*'), - allowUnscheduled = cms.obsolete.untracked.bool, - canDeleteEarly = cms.untracked.vstring(), - deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), - dumpOptions = cms.untracked.bool(False), - emptyRunLumiMode = cms.obsolete.untracked.string, - eventSetup = cms.untracked.PSet( - forceNumberOfConcurrentIOVs = cms.untracked.PSet( - allowAnyLabel_=cms.required.untracked.uint32 - ), - numberOfConcurrentIOVs = cms.untracked.uint32(0) - ), - fileMode = cms.untracked.string('FULLMERGE'), - forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), - holdsReferencesToDeleteEarly = cms.untracked.VPSet(), - makeTriggerResults = cms.obsolete.untracked.bool, - modulesToIgnoreForDeleteEarly = cms.untracked.vstring(), - numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), - numberOfConcurrentRuns = cms.untracked.uint32(1), - numberOfStreams = cms.untracked.uint32(0), - numberOfThreads = cms.untracked.uint32(1), - printDependencies = cms.untracked.bool(False), - sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, - throwIfIllegalParameter = cms.untracked.bool(True), - wantSummary = cms.untracked.bool(False) -) - -# Production Info -process.configurationMetadata = cms.untracked.PSet( - annotation = cms.untracked.string('step1 nevts:-1'), - name = cms.untracked.string('Applications'), - version = cms.untracked.string('$Revision: 1.19 $') -) - -# Output definition - -process.NANOAODSIMoutput = cms.OutputModule("NanoAODOutputModule", - compressionAlgorithm = cms.untracked.string('LZMA'), - compressionLevel = cms.untracked.int32(9), - dataset = cms.untracked.PSet( - dataTier = cms.untracked.string('NANOAODSIM'), - filterName = cms.untracked.string('') - ), - fileName = cms.untracked.string('file:NanoFromMini_mcRun3.root'), - outputCommands = process.NANOAODSIMEventContent.outputCommands -) - -# Additional output definition - -# Other statements -from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, '124X_mcRun3_2022_realistic_v12', '') - -# Path and EndPath definitions -process.nanoAOD_step = cms.Path(process.nanoSequenceMC) -process.endjob_step = cms.EndPath(process.endOfProcess) -process.NANOAODSIMoutput_step = cms.EndPath(process.NANOAODSIMoutput) - -# Schedule definition -process.schedule = cms.Schedule(process.nanoAOD_step,process.endjob_step,process.NANOAODSIMoutput_step) -from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask -associatePatAlgosToolsTask(process) - -#Setup FWK for multithreaded -process.options.numberOfThreads = 4 -process.options.numberOfStreams = 0 - -# customisation of the process. - -# Automatic addition of the customisation function from PhysicsTools.NanoAOD.nano_cff -from PhysicsTools.NanoAOD.nano_cff import nanoAOD_customizeCommon - -#call to customisation function nanoAOD_customizeCommon imported from PhysicsTools.NanoAOD.nano_cff -process = nanoAOD_customizeCommon(process) - -# End of customisation functions - - -# Customisation from command line - -process.add_(cms.Service('InitRootHandlers', EnableIMT = cms.untracked.bool(False)));process.MessageLogger.cerr.FwkReport.reportEvery=100 -# Add early deletion of temporary data products to reduce peak memory need -from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete -process = customiseEarlyDelete(process) -# End adding early deletion diff --git a/RecoBTag/ONNXRuntime/test/step1_PAT.py b/RecoBTag/ONNXRuntime/test/step1_PAT.py deleted file mode 100644 index aaca1d87bb174..0000000000000 --- a/RecoBTag/ONNXRuntime/test/step1_PAT.py +++ /dev/null @@ -1,215 +0,0 @@ -# Auto generated configuration file -# using: -# Revision: 1.19 -# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v -# with command line options: step1 --mc --eventcontent MINIAODSIM --datatier MINIAODSIM --conditions 124X_mcRun3_2022_realistic_v12 --step PAT --nThreads 4 --geometry DB:Extended --era Run3 --filein file:AODinput_mcRun3.root --fileout file:miniFromAOD_mcRun3.root --no_exec -n 400 -import FWCore.ParameterSet.Config as cms - -from Configuration.Eras.Era_Run3_cff import Run3 - -process = cms.Process('PAT',Run3) - -# import of standard configurations -process.load('Configuration.StandardSequences.Services_cff') -process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') -process.load('FWCore.MessageService.MessageLogger_cfi') -process.load('Configuration.EventContent.EventContent_cff') -process.load('SimGeneral.MixingModule.mixNoPU_cfi') -process.load('Configuration.StandardSequences.GeometryRecoDB_cff') -process.load('Configuration.StandardSequences.MagneticField_cff') -process.load('PhysicsTools.PatAlgos.slimming.metFilterPaths_cff') -process.load('Configuration.StandardSequences.PATMC_cff') -process.load('Configuration.StandardSequences.EndOfProcess_cff') -process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') - -process.maxEvents = cms.untracked.PSet( - input = cms.untracked.int32(400), - output = cms.optional.untracked.allowed(cms.int32,cms.PSet) -) - -# Input source -process.source = cms.Source("PoolSource", - fileNames = cms.untracked.vstring('file:/afs/cern.ch/work/a/anstein/public/CMSSW_12_6_0_patch1/src/RecoBTag/ONNXRuntime/test/AODinput_mcRun3.root'), - secondaryFileNames = cms.untracked.vstring() -) - -process.options = cms.untracked.PSet( - FailPath = cms.untracked.vstring(), - IgnoreCompletely = cms.untracked.vstring(), - Rethrow = cms.untracked.vstring(), - SkipEvent = cms.untracked.vstring(), - accelerators = cms.untracked.vstring('*'), - allowUnscheduled = cms.obsolete.untracked.bool, - canDeleteEarly = cms.untracked.vstring(), - deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), - dumpOptions = cms.untracked.bool(False), - emptyRunLumiMode = cms.obsolete.untracked.string, - eventSetup = cms.untracked.PSet( - forceNumberOfConcurrentIOVs = cms.untracked.PSet( - allowAnyLabel_=cms.required.untracked.uint32 - ), - numberOfConcurrentIOVs = cms.untracked.uint32(0) - ), - fileMode = cms.untracked.string('FULLMERGE'), - forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), - holdsReferencesToDeleteEarly = cms.untracked.VPSet(), - makeTriggerResults = cms.obsolete.untracked.bool, - modulesToIgnoreForDeleteEarly = cms.untracked.vstring(), - numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), - numberOfConcurrentRuns = cms.untracked.uint32(1), - numberOfStreams = cms.untracked.uint32(0), - numberOfThreads = cms.untracked.uint32(4), - printDependencies = cms.untracked.bool(False), - sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, - throwIfIllegalParameter = cms.untracked.bool(True), - wantSummary = cms.untracked.bool(True) - #wantSummary = cms.untracked.bool(False) -) - -# Production Info -process.configurationMetadata = cms.untracked.PSet( - annotation = cms.untracked.string('step1 nevts:4000'), - name = cms.untracked.string('Applications'), - version = cms.untracked.string('$Revision: 1.19 $') -) - -process.MessageLogger.cerr.FwkReport.reportEvery=10 - -# Output definition - -process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule", - compressionAlgorithm = cms.untracked.string('LZMA'), - compressionLevel = cms.untracked.int32(4), - dataset = cms.untracked.PSet( - dataTier = cms.untracked.string('MINIAODSIM'), - filterName = cms.untracked.string('') - ), - dropMetaData = cms.untracked.string('ALL'), - eventAutoFlushCompressedSize = cms.untracked.int32(-900), - fastCloning = cms.untracked.bool(False), - #fileName = cms.untracked.string('file:miniFromAOD_mcRun3.root'), - fileName = cms.untracked.string('file:miniFromAOD_mcRun3_withParT.root'), - outputCommands = process.MINIAODSIMEventContent.outputCommands, - overrideBranchesSplitLevel = cms.untracked.VPSet( - cms.untracked.PSet( - branch = cms.untracked.string('patPackedCandidates_packedPFCandidates__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoGenParticles_prunedGenParticles__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patTriggerObjectStandAlones_slimmedPatTrigger__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patPackedGenParticles_packedGenParticles__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patJets_slimmedJets__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVertices__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVerticesWithBS__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoCaloClusters_reducedEgamma_reducedESClusters_*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEBRecHits_*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEERecHits_*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoGenJets_slimmedGenJets__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patJets_slimmedJetsPuppi__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedESRecHits_*'), - splitLevel = cms.untracked.int32(99) - ) - ), - overrideInputFileSplitLevels = cms.untracked.bool(True), - splitLevel = cms.untracked.int32(0) -) - -# Additional output definition - -# Other statements -from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, '124X_mcRun3_2022_realistic_v12', '') - -# Path and EndPath definitions -process.Flag_BadChargedCandidateFilter = cms.Path(process.BadChargedCandidateFilter) -process.Flag_BadChargedCandidateSummer16Filter = cms.Path(process.BadChargedCandidateSummer16Filter) -process.Flag_BadPFMuonDzFilter = cms.Path(process.BadPFMuonDzFilter) -process.Flag_BadPFMuonFilter = cms.Path(process.BadPFMuonFilter) -process.Flag_BadPFMuonSummer16Filter = cms.Path(process.BadPFMuonSummer16Filter) -process.Flag_CSCTightHalo2015Filter = cms.Path(process.CSCTightHalo2015Filter) -process.Flag_CSCTightHaloFilter = cms.Path(process.CSCTightHaloFilter) -process.Flag_CSCTightHaloTrkMuUnvetoFilter = cms.Path(process.CSCTightHaloTrkMuUnvetoFilter) -process.Flag_EcalDeadCellBoundaryEnergyFilter = cms.Path(process.EcalDeadCellBoundaryEnergyFilter) -process.Flag_EcalDeadCellTriggerPrimitiveFilter = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter) -process.Flag_HBHENoiseFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseFilter) -process.Flag_HBHENoiseIsoFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseIsoFilter) -process.Flag_HcalStripHaloFilter = cms.Path(process.HcalStripHaloFilter) -process.Flag_METFilters = cms.Path(process.metFilters) -process.Flag_chargedHadronTrackResolutionFilter = cms.Path(process.chargedHadronTrackResolutionFilter) -process.Flag_ecalBadCalibFilter = cms.Path(process.ecalBadCalibFilter) -process.Flag_ecalLaserCorrFilter = cms.Path(process.ecalLaserCorrFilter) -process.Flag_eeBadScFilter = cms.Path(process.eeBadScFilter) -process.Flag_globalSuperTightHalo2016Filter = cms.Path(process.globalSuperTightHalo2016Filter) -process.Flag_globalTightHalo2016Filter = cms.Path(process.globalTightHalo2016Filter) -process.Flag_goodVertices = cms.Path(process.primaryVertexFilter) -process.Flag_hcalLaserEventFilter = cms.Path(process.hcalLaserEventFilter) -process.Flag_hfNoisyHitsFilter = cms.Path(process.hfNoisyHitsFilter) -process.Flag_muonBadTrackFilter = cms.Path(process.muonBadTrackFilter) -process.Flag_trackingFailureFilter = cms.Path(process.goodVertices+process.trackingFailureFilter) -process.Flag_trkPOGFilters = cms.Path(process.trkPOGFilters) -process.Flag_trkPOG_logErrorTooManyClusters = cms.Path(~process.logErrorTooManyClusters) -process.Flag_trkPOG_manystripclus53X = cms.Path(~process.manystripclus53X) -process.Flag_trkPOG_toomanystripclus53X = cms.Path(~process.toomanystripclus53X) -process.endjob_step = cms.EndPath(process.endOfProcess) -process.MINIAODSIMoutput_step = cms.EndPath(process.MINIAODSIMoutput) - -# Schedule definition -process.schedule = cms.Schedule(process.Flag_HBHENoiseFilter,process.Flag_HBHENoiseIsoFilter,process.Flag_CSCTightHaloFilter,process.Flag_CSCTightHaloTrkMuUnvetoFilter,process.Flag_CSCTightHalo2015Filter,process.Flag_globalTightHalo2016Filter,process.Flag_globalSuperTightHalo2016Filter,process.Flag_HcalStripHaloFilter,process.Flag_hcalLaserEventFilter,process.Flag_EcalDeadCellTriggerPrimitiveFilter,process.Flag_EcalDeadCellBoundaryEnergyFilter,process.Flag_ecalBadCalibFilter,process.Flag_goodVertices,process.Flag_eeBadScFilter,process.Flag_ecalLaserCorrFilter,process.Flag_trkPOGFilters,process.Flag_chargedHadronTrackResolutionFilter,process.Flag_muonBadTrackFilter,process.Flag_BadChargedCandidateFilter,process.Flag_BadPFMuonFilter,process.Flag_BadPFMuonDzFilter,process.Flag_hfNoisyHitsFilter,process.Flag_BadChargedCandidateSummer16Filter,process.Flag_BadPFMuonSummer16Filter,process.Flag_trkPOG_manystripclus53X,process.Flag_trkPOG_toomanystripclus53X,process.Flag_trkPOG_logErrorTooManyClusters,process.Flag_METFilters,process.endjob_step,process.MINIAODSIMoutput_step) -process.schedule.associate(process.patTask) -from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask -associatePatAlgosToolsTask(process) - -#Setup FWK for multithreaded -process.options.numberOfThreads = 4 -process.options.numberOfStreams = 0 - -# customisation of the process. - -# Automatic addition of the customisation function from PhysicsTools.PatAlgos.slimming.miniAOD_tools -from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC - -#call to customisation function miniAOD_customizeAllMC imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools -process = miniAOD_customizeAllMC(process) - -# End of customisation functions - -# Customisation from command line - -# Add early deletion of temporary data products to reduce peak memory need -from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete -process = customiseEarlyDelete(process) -# End adding early deletion \ No newline at end of file diff --git a/RecoBTag/ONNXRuntime/test/testONNXsess.py b/RecoBTag/ONNXRuntime/test/testONNXsess.py deleted file mode 100644 index adcd1024a7cdb..0000000000000 --- a/RecoBTag/ONNXRuntime/test/testONNXsess.py +++ /dev/null @@ -1,73 +0,0 @@ -import onnxruntime as ort -import numpy as np -np.random.seed = 42 -print('ONNXRuntime version: ', ort.__version__) -# create input data in the float format (32 bit) - -data1 = np.ones((1, 25, 16)).astype(np.float32) -#data2 = np.ones((1, 25, 8)).astype(np.float32) -data2 = np.random.rand(1, 25, 8).astype(np.float32) -#data3 = np.ones((1, 5, 14)).astype(np.float32) -data3 = np.array([[[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], - [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], - [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], - [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], - # [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], - [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0, 0] - ] - ]).astype(np.float32) -data4 = np.ones((1, 25, 4)).astype(np.float32) -data5 = np.ones((1, 25, 4)).astype(np.float32) -#data6 = np.zeros((1, 5, 4)).astype(np.float32) -data6 = np.array([[[1., 1., 1., 1.], - [1., 1., 1., 1.], - [1., 1., 1., 1.], - [1., 1., 1., 1.], -# [1., 1., 1., 1.], - [0., 0., 0., 0.] - ] - ]).astype(np.float32) -# create inference session using ort.InferenceSession from a given model -ort_sess = ort.InferenceSession('/afs/cern.ch/work/a/anstein/private/ParTPUPPI/CMSSW_13_1_0_pre2/src/RecoBTag/Combined/data/RobustParTAK4/PUPPI/V00/DJT.onnx', providers=[ - #'CUDAExecutionProvider', - 'CPUExecutionProvider']) - -# run inference -outputs = ort_sess.run(None, {'input_1': data1, - 'input_2': data2, - 'input_3': data3, - 'input_4': data4, - 'input_5': data5, - 'input_6': data6})[0] - -# print input and output -# print('input ->', data) -#print('input ->', data1, data2, data3, data4, data5, data6) -print('output ->', outputs) - - - -# data1 = np.ones((1, 25, 16)).astype(np.float32) -# data2 = np.ones((1, 25, 8)).astype(np.float32) -# data3 = np.ones((1, 4, 14)).astype(np.float32) -# data4 = np.ones((1, 25, 4)).astype(np.float32) -# data5 = np.ones((1, 25, 4)).astype(np.float32) -# data6 = np.ones((1, 4, 4)).astype(np.float32) -# create inference session using ort.InferenceSessio -# create inference session using ort.InferenceSession from a given model -ort_sess = ort.InferenceSession('/afs/cern.ch/work/a/anstein/private/ParTPUPPI/CMSSW_13_1_0_pre2/src/RecoBTag/Combined/data/RobustParTAK4/PUPPI/V00/DJT_build4v.onnx', providers=[ - #'CUDAExecutionProvider', - 'CPUExecutionProvider']) - -# run inference -outputs = ort_sess.run(None, {'input_1': data1, - 'input_2': data2, - 'input_3': data3, - 'input_4': data4, - 'input_5': data5, - 'input_6': data6})[0] - -# print input and output -# print('input ->', data) -# print('input ->', data1, data2, data3, data4, data5, data6) -print('output ->', outputs) \ No newline at end of file From 92ea010c93bcf1196042ffb450a215c9adeac4c2 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Wed, 5 Apr 2023 13:57:05 +0200 Subject: [PATCH 08/17] restore puppiw compatibility after merging --- .../ParticleTransformerAK4TagInfoProducer.cc | 50 +++++++++++++++---- 1 file changed, 41 insertions(+), 9 deletions(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index db3e3ae685114..2aa19e4095db2 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -90,6 +90,9 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { bool fallback_puppi_weight_; bool fallback_vertex_association_; + + bool is_weighted_jet_; + const double min_jet_pt_; const double max_jet_eta_; }; @@ -108,6 +111,7 @@ ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(con 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(); @@ -116,6 +120,9 @@ ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(con 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"); @@ -142,6 +149,7 @@ void ParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationD 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); @@ -282,13 +290,34 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed } else if (pat_jet && reco_cand) { reco_ptr = pat_jet->getPFConstituent(i); } - // get PUPPI weight from value map - float puppiw = 1.0; // fallback value - if (reco_cand && use_puppi_value_map_) { - puppiw = (*puppi_value_map)[reco_ptr]; - } else if (reco_cand && !fallback_puppi_weight_) { - throw edm::Exception(edm::errors::InvalidReference, "PUPPI value map missing") - << "use fallback_puppi_weight option to use " << puppiw << "as default"; + + 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); @@ -314,8 +343,10 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed btagbtvdeep::packedCandidateToFeatures(packed_cand, jet, trackinfo, + is_weighted_jet_, drminpfcandsv, static_cast(jet_radius_), + puppiw, c_pf_features, flip_, distminpfcandsv); @@ -350,6 +381,7 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed btagbtvdeep::recoCandidateToFeatures(reco_cand, jet, trackinfo, + is_weighted_jet_, drminpfcandsv, static_cast(jet_radius_), puppiw, @@ -367,10 +399,10 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed // fill feature structure if (packed_cand) { btagbtvdeep::packedCandidateToFeatures( - packed_cand, jet, drminpfcandsv, static_cast(jet_radius_), n_pf_features); + packed_cand, jet, is_weighted_jet_, drminpfcandsv, static_cast(jet_radius_), puppiw, n_pf_features); } else if (reco_cand) { btagbtvdeep::recoCandidateToFeatures( - reco_cand, jet, drminpfcandsv, static_cast(jet_radius_), puppiw, n_pf_features); + reco_cand, jet, is_weighted_jet_, drminpfcandsv, static_cast(jet_radius_), puppiw, n_pf_features); } } } From fdca404741376c21d71a9fc559879c6a572654dc Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Wed, 5 Apr 2023 14:19:53 +0200 Subject: [PATCH 09/17] code-format again --- .../plugins/ParticleTransformerAK4TagInfoProducer.cc | 6 +++--- RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc | 6 ++++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index 2aa19e4095db2..7336273ec7ce7 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -90,9 +90,9 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { bool fallback_puppi_weight_; bool fallback_vertex_association_; - + bool is_weighted_jet_; - + const double min_jet_pt_; const double max_jet_eta_; }; @@ -290,7 +290,7 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed } 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); diff --git a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc index 6a6ca1a81b3d1..5209c7d2818c4 100644 --- a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc +++ b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc @@ -12,7 +12,8 @@ namespace btagbtvdeep { ChargedCandidateFeatures& c_pf_features, const bool flip, const float distminpfcandsv) { - commonCandidateToFeatures(c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, c_pf_features, flip, distminpfcandsv); + commonCandidateToFeatures( + c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, c_pf_features, flip, distminpfcandsv); c_pf_features.vtx_ass = c_pf->pvAssociationQuality(); @@ -49,7 +50,8 @@ namespace btagbtvdeep { ChargedCandidateFeatures& c_pf_features, const bool flip, const float distminpfcandsv) { - commonCandidateToFeatures(c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, c_pf_features, flip, 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; From 7a383cd7e4ac2015f1b6ddd4b8e634a9b7f2fe23 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Wed, 5 Apr 2023 18:36:19 +0200 Subject: [PATCH 10/17] update custom_jme, nanoDQM --- PhysicsTools/NanoAOD/python/custom_jme_cff.py | 16 +++++----------- PhysicsTools/NanoAOD/python/nanoDQM_cff.py | 5 +++++ PhysicsTools/NanoAOD/python/nanoDQM_cfi.py | 9 ++++----- 3 files changed, 14 insertions(+), 16 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/custom_jme_cff.py b/PhysicsTools/NanoAOD/python/custom_jme_cff.py index b4ce4c37bee5d..4a93b44f5c2e9 100644 --- a/PhysicsTools/NanoAOD/python/custom_jme_cff.py +++ b/PhysicsTools/NanoAOD/python/custom_jme_cff.py @@ -26,7 +26,7 @@ ] from RecoBTag.ONNXRuntime.pfParticleNetAK4_cff import _pfParticleNetAK4JetTagsAll from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll -bTagDiscriminatorsForAK4 = cms.PSet(foo = cms.vstring(bTagDeepCSV+bTagDeepJet+_pfParticleNetAK4JetTagsAll+_pfParticleTransformerAK4JetTagsAll)) +bTagDiscriminatorsForAK4 = cms.PSet(foo = cms.vstring(bTagDeepJet+_pfParticleNetAK4JetTagsAll+_pfParticleTransformerAK4JetTagsAll)) run2_nanoAOD_ANY.toModify( bTagDiscriminatorsForAK4, foo = bTagCSVV2+bTagDeepCSV+bTagDeepJet+_pfParticleNetAK4JetTagsAll @@ -380,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 @@ -711,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 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'), From 7ce96e9ab7d9fbaf0f09d783a19119f37ae12bbd Mon Sep 17 00:00:00 2001 From: Annika Stein <53974095+AnnikaStein@users.noreply.github.com> Date: Thu, 6 Apr 2023 23:48:04 +0200 Subject: [PATCH 11/17] merge from master (#2) * added EXOLLPJetHCAL skim (initial version) * added test script test_EXOLLPJetHCAL_SKIM.py * Replace cout with edm::Logverbatim in Geometry/GlobalTrackingGeometryBuilder * Re-enable unit tests for ASAN build * dd4hep phase2 wf * Add wf *.81 for BPH DQM * Added utility script edmFileInPath * improve unt test; use edmFileInPath; convert to bash * Replace std::cout with edm::LogVerbatim in Geometry/HcalEventSetup and Geometry/HcalTestBeamData. Also add some missing files needed for testing * Code check * Remove FWCore TestHelper utility * Add ap_data type for GT interface Update GMT emulator for new ap format Also clean up the config file Update Z0/D0 according to GT Using 0.05 for Z0 and 0.03 for d0. update code format Bug fix in tracker muon matching Thanks to Santi for spotting this. This line was commented out by someone, likely by accident. Update the reference type to SA muons * improve unit test testCreateRandomMisalignment * Add back removed data version * fix bug in computation of barycenters per partition and improve graphical display * get rid of gROOT->Reset() in GeometryComparisonPlotter.cc --------- Co-authored-by: Kiley Kennedy Co-authored-by: Sunanda Co-authored-by: Shahzad Malik Muzaffar Co-authored-by: Norraphat Co-authored-by: AdrianoDee Co-authored-by: Zhenbin Wu Co-authored-by: cmsbuild Co-authored-by: mmusich Co-authored-by: Andrew David Loeliger --- .../src/GeometryComparisonPlotter.cc | 2 - ...teRandomlyMisalignedGeometry_Phase2_cfg.py | 16 - .../test/testCreateRandomMisalignment.sh | 7 +- .../AlignmentPayloadInspectorHelper.h | 17 +- .../TrackerAlignment_PayloadInspector.cc | 5 +- CondTools/Hcal/test/BuildFile.xml | 5 +- ...ts_db_io_test.csh => pfcuts_db_io_test.sh} | 19 +- Configuration/PyReleaseValidation/README.md | 2 + .../PyReleaseValidation/python/relval_2026.py | 4 +- .../python/upgradeWorkflowComponents.py | 28 ++ .../scripts/runTheMatrix.py | 4 +- .../Skimming/python/PDWG_EXOLLPJetHCAL_cff.py | 15 + .../Skimming/python/Skims_PDWG_cff.py | 11 + .../Skimming/test/test_EXOLLPJetHCAL_SKIM.py | 403 ++++++++++++++++++ DQM/Integration/test/BuildFile.xml | 3 - DataFormats/FWLite/test/test.cppunit.cpp | 16 +- .../L1TMuonPhase2/interface/Constants.h | 46 +- DataFormats/L1TMuonPhase2/interface/SAMuon.h | 10 + .../L1TMuonPhase2/interface/TrackerMuon.h | 18 +- DataFormats/L1TMuonPhase2/src/classes_def.xml | 3 +- FWCore/FWLite/test/BuildFile.xml | 3 + FWCore/FWLite/test/ref_t.cppunit.cpp | 24 +- FWCore/Services/test/BuildFile.xml | 7 +- FWCore/Utilities/interface/TestHelper.h | 33 -- FWCore/Utilities/scripts/edmFileInPath | 21 + FWCore/Utilities/src/TestHelper.cc | 192 --------- FWCore/Utilities/test/README | 48 --- .../test/GlobalTrackingGeometryTest.cc | 61 ++- .../test/testGlobalTrackingGeometry_cfg.py | 14 +- .../python/HcalDDDGeometry_cfi.py | 8 + .../HcalEventSetup/src/HcalTopologyIdealEP.cc | 18 +- .../test/runTestHcalDDDGeometry_cfg.py | 20 +- .../dd4hep/cms-test-ddTB2006-algorithm.xml | 47 ++ .../dd4hep/cms-test-ddTB2007-algorithm.xml | 50 +++ .../plugins/HcalTBParameterTester.cc | 15 +- .../SonicTriton/test/BuildFile.xml | 3 - .../plugins/Phase2L1TGMTSAMuonProducer.cc | 14 +- .../plugins/TrackMuonMatchAlgorithm.h | 6 +- L1Trigger/Phase2L1GMT/python/gmt_cfi.py | 2 +- L1Trigger/Phase2L1GMT/test/runGMT.py | 20 - .../EgammaClusterProducers/test/BuildFile.xml | 6 +- 41 files changed, 763 insertions(+), 483 deletions(-) rename CondTools/Hcal/test/{pfcuts_db_io_test.csh => pfcuts_db_io_test.sh} (89%) create mode 100644 Configuration/Skimming/python/PDWG_EXOLLPJetHCAL_cff.py create mode 100644 Configuration/Skimming/test/test_EXOLLPJetHCAL_SKIM.py delete mode 100644 FWCore/Utilities/interface/TestHelper.h create mode 100755 FWCore/Utilities/scripts/edmFileInPath delete mode 100644 FWCore/Utilities/src/TestHelper.cc delete mode 100644 FWCore/Utilities/test/README create mode 100644 Geometry/HcalEventSetup/python/HcalDDDGeometry_cfi.py create mode 100644 Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2006-algorithm.xml create mode 100644 Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2007-algorithm.xml diff --git a/Alignment/OfflineValidation/src/GeometryComparisonPlotter.cc b/Alignment/OfflineValidation/src/GeometryComparisonPlotter.cc index 45f95d0bfc55e..36df70af29971 100644 --- a/Alignment/OfflineValidation/src/GeometryComparisonPlotter.cc +++ b/Alignment/OfflineValidation/src/GeometryComparisonPlotter.cc @@ -154,8 +154,6 @@ GeometryComparisonPlotter::GeometryComparisonPlotter(TString tree_file_name, #endif // style - gROOT->Reset(); - data->SetMarkerSize(0.5); data->SetMarkerStyle(6); diff --git a/Alignment/TrackerAlignment/test/Misalignments/createRandomlyMisalignedGeometry_Phase2_cfg.py b/Alignment/TrackerAlignment/test/Misalignments/createRandomlyMisalignedGeometry_Phase2_cfg.py index 31652b0bf7704..a43aeacdda74c 100644 --- a/Alignment/TrackerAlignment/test/Misalignments/createRandomlyMisalignedGeometry_Phase2_cfg.py +++ b/Alignment/TrackerAlignment/test/Misalignments/createRandomlyMisalignedGeometry_Phase2_cfg.py @@ -55,24 +55,8 @@ process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') from Configuration.AlCa.GlobalTag import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic_T21', '') # using realistic Phase 2 geom -process.GlobalTag.toGet = cms.VPSet( - cms.PSet(record = cms.string("TrackerAlignmentRcd"), - tag = cms.string("Alignments"), - connect = cms.string('sqlite_file:/afs/cern.ch/user/m/musich/public/forSandra/tracker_alignment_phase2_D88130X_mcRun4_realistic_v2.db') - ), - cms.PSet(record = cms.string("TrackerAlignmentErrorExtendedRcd"), - tag = cms.string("AlignmentErrorsExtended"), - connect = cms.string('sqlite_file:/afs/cern.ch/user/m/musich/public/forSandra/tracker_alignment_phase2_D88130X_mcRun4_realistic_v2.db') - ), - cms.PSet(record = cms.string("TrackerSurfaceDeformationRcd"), - tag = cms.string("AlignmentSurfaceDeformations"), - connect = cms.string('sqlite_file:/afs/cern.ch/user/m/musich/public/forSandra/tracker_alignment_phase2_D88130X_mcRun4_realistic_v2.db') - ) -) - print("Using global tag:", process.GlobalTag.globaltag.value()) - ################################################################### # This uses the object from the tag and applies the misalignment scenario on top of that object ################################################################### diff --git a/Alignment/TrackerAlignment/test/testCreateRandomMisalignment.sh b/Alignment/TrackerAlignment/test/testCreateRandomMisalignment.sh index cd8b92e2b3f40..6d6f3dc98a7bc 100755 --- a/Alignment/TrackerAlignment/test/testCreateRandomMisalignment.sh +++ b/Alignment/TrackerAlignment/test/testCreateRandomMisalignment.sh @@ -1,8 +1,9 @@ -#! /bin/bash +#!/bin/bash +function die { echo $1: status $2 ; exit $2; } folder=$CMSSW_BASE/src/Alignment/TrackerAlignment/test/Misalignments for a in $(ls $folder); do - echo "running " ${a} - cmsRun $folder/${a} + echo "running unit test: " ${a} + cmsRun $folder/${a} || die "Failure running ${a}" $? done diff --git a/CondCore/AlignmentPlugins/interface/AlignmentPayloadInspectorHelper.h b/CondCore/AlignmentPlugins/interface/AlignmentPayloadInspectorHelper.h index 96783ba718b61..7b318c32dd4e3 100644 --- a/CondCore/AlignmentPlugins/interface/AlignmentPayloadInspectorHelper.h +++ b/CondCore/AlignmentPlugins/interface/AlignmentPayloadInspectorHelper.h @@ -882,6 +882,17 @@ namespace AlignmentPI { virtual ~TkAlBarycenters() {} }; + /*--------------------------------------------------------------------*/ + inline void TkAlBarycenters::init() + /*--------------------------------------------------------------------*/ + { + // empty all maps + Xbarycenters.clear(); + Ybarycenters.clear(); + Zbarycenters.clear(); + nmodules.clear(); + } + /*--------------------------------------------------------------------*/ inline GlobalPoint TkAlBarycenters::getPartitionAvg(AlignmentPI::PARTITION p) /*--------------------------------------------------------------------*/ @@ -895,10 +906,8 @@ namespace AlignmentPI { const std::map& GPR) /*--------------------------------------------------------------------*/ { - // zero in the n. modules per partition... - for (const auto& p : PARTITIONS) { - nmodules[p] = 0.; - } + // clear all data members; + init(); for (const auto& ali : input) { if (DetId(ali.rawId()).det() != DetId::Tracker) { diff --git a/CondCore/AlignmentPlugins/plugins/TrackerAlignment_PayloadInspector.cc b/CondCore/AlignmentPlugins/plugins/TrackerAlignment_PayloadInspector.cc index a52d4e26a7672..f2a185b230615 100644 --- a/CondCore/AlignmentPlugins/plugins/TrackerAlignment_PayloadInspector.cc +++ b/CondCore/AlignmentPlugins/plugins/TrackerAlignment_PayloadInspector.cc @@ -693,6 +693,7 @@ namespace { bool fill() override { auto tag = PlotBase::getTag<0>(); auto iov = tag.iovs.front(); + const auto &tagname = PlotBase::getTag<0>().name; std::shared_ptr payload = fetchPayload(std::get<1>(iov)); unsigned int run = std::get<0>(iov); @@ -794,8 +795,8 @@ namespace { TLatex t1; t1.SetNDC(); t1.SetTextAlign(26); - t1.SetTextSize(0.05); - t1.DrawLatex(0.5, 0.96, Form("Tracker Alignment Barycenters, IOV %i", run)); + t1.SetTextSize(0.045); + t1.DrawLatex(0.5, 0.96, Form("TkAl Barycenters, Tag: #color[4]{%s}, IOV #color[4]{%i}", tagname.c_str(), run)); t1.SetTextSize(0.025); std::string fileName(m_imageFileName); diff --git a/CondTools/Hcal/test/BuildFile.xml b/CondTools/Hcal/test/BuildFile.xml index 7f00bc545196c..2bd964c9b3292 100644 --- a/CondTools/Hcal/test/BuildFile.xml +++ b/CondTools/Hcal/test/BuildFile.xml @@ -31,10 +31,7 @@ - - - - + diff --git a/CondTools/Hcal/test/pfcuts_db_io_test.csh b/CondTools/Hcal/test/pfcuts_db_io_test.sh similarity index 89% rename from CondTools/Hcal/test/pfcuts_db_io_test.csh rename to CondTools/Hcal/test/pfcuts_db_io_test.sh index dd31b1a8088e3..701b5a8ca271a 100755 --- a/CondTools/Hcal/test/pfcuts_db_io_test.csh +++ b/CondTools/Hcal/test/pfcuts_db_io_test.sh @@ -1,10 +1,7 @@ -#!/bin/csh +#!/bin/bash -ex -set inputfile = `ls -1 $CMSSW_DATA_PATH/data-CondTools-Hcal/V*/CondTools/Hcal/data/hcalpfcuts.txt | tail -1` -set inputdir = `dirname $inputfile` -setenv CMSSW_SEARCH_PATH ${CMSSW_SEARCH_PATH}:$inputdir - -cat >! temp_pfcuts_to_db.py <<% +inputfile=$(edmFileInPath CondTools/Hcal/data/hcalpfcuts.txt) +cat << \EOF > temp_pfcuts_to_db.py import FWCore.ParameterSet.Config as cms from Configuration.StandardSequences.Eras import eras @@ -34,7 +31,7 @@ process.es_ascii = cms.ESSource("HcalTextCalibrations", input = cms.VPSet( cms.PSet( object = cms.string("PFCuts"), - file = cms.FileInPath("hcalpfcuts.txt") + file = cms.FileInPath("CondTools/Hcal/data/hcalpfcuts.txt") ) ) ) @@ -59,11 +56,12 @@ process.mytest = cms.EDAnalyzer("HcalPFCutsPopConAnalyzer", ) ) process.p = cms.Path(process.mytest) -% +EOF + cmsRun temp_pfcuts_to_db.py rm temp_pfcuts_to_db.py -cat >! temp_pfcuts_from_db.py <<% +cat << \EOF > temp_pfcuts_from_db.py import FWCore.ParameterSet.Config as cms from Configuration.StandardSequences.Eras import eras @@ -101,7 +99,8 @@ process.dumpcond = cms.EDAnalyzer("HcalDumpConditions", dump = cms.untracked.vstring("PFCuts") ) process.p = cms.Path(process.dumpcond) -% +EOF + cmsRun temp_pfcuts_from_db.py rm temp_pfcuts_from_db.py diff --git a/Configuration/PyReleaseValidation/README.md b/Configuration/PyReleaseValidation/README.md index e8a7ccd150dd8..33908547fbec0 100644 --- a/Configuration/PyReleaseValidation/README.md +++ b/Configuration/PyReleaseValidation/README.md @@ -52,6 +52,7 @@ The offsets currently in use are: * 0.601: HLT as separate step * 0.7: trackingMkFit modifier * 0.8: BPH Parking (Run-2) +* 0.81: Running also HeavyFlavor DQM * 0.9: Vector hits * 0.12: Neutron background * 0.13: MLPF algorithm @@ -84,3 +85,4 @@ The offsets currently in use are: * 0.9001: Sonic Triton * 0.278: Weighted Vertexing in Blocks * 0.279: Weighted Vertexing in Blocks and tracking only wf + diff --git a/Configuration/PyReleaseValidation/python/relval_2026.py b/Configuration/PyReleaseValidation/python/relval_2026.py index 726eb236ac0bc..857b5cdc121d5 100644 --- a/Configuration/PyReleaseValidation/python/relval_2026.py +++ b/Configuration/PyReleaseValidation/python/relval_2026.py @@ -15,7 +15,7 @@ #2026 WFs to run in IB (TTbar) numWFIB = [] numWFIB.extend([20034.0]) #2026D86 -numWFIB.extend([20834.0,20834.911,20834.103]) #2026D88 DDD XML, DD4hep XML, aging +numWFIB.extend([20834.0]) #2026D88 numWFIB.extend([21061.97]) #2026D88 premixing stage1 (NuGun+PU) numWFIB.extend([20834.5,20834.9,20834.501,20834.502]) #2026D88 pixelTrackingOnly, vector hits, Patatrack local reconstruction on CPU, Patatrack local reconstruction on GPU numWFIB.extend([21034.99,21034.999]) #2026D88 premixing combined stage1+stage2 (ttbar+PU200, ttbar+PU50 for PR test) @@ -33,7 +33,7 @@ numWFIB.extend([24034.0]) #2026D96 numWFIB.extend([24434.0]) #2026D97 numWFIB.extend([24834.0]) #2026D98 -numWFIB.extend([25234.0]) #2026D99 +numWFIB.extend([25234.0,25234.911]) #2026D99 DDD XML, DD4hep XML #Additional sample for short matrix and IB #CloseByPGun for HGCAL diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 18b5679ea2fe2..77c9ce19d9625 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -1756,6 +1756,34 @@ def condition(self, fragment, stepList, key, hasHarvest): offset = 0.8, ) +## Wf to add Heavy Flavor DQM to whichever DQM is already there +class UpgradeWorkflow_HeavyFlavor(UpgradeWorkflow): + def setup_(self, step, stepName, stepDict, k, properties): + self.__frags = ["B0","Psi2S","Bu","Bd","Xi","Bs"] + thisStep = stepDict[step][k]["-s"] + if "Reco" in step: + if "DQM:" in thisStep: + #print(thisStep.replace("DQM:","DQM:@heavyFlavor+")) + stepDict[stepName][k] = merge([{'-s': thisStep.replace("DQM:","DQM:@heavyFlavor+")}, stepDict[step][k]]) + #print(k) + elif "DQM" in thisStep: + stepDict[stepName][k] = merge([{'-s': thisStep.replace("DQM","DQM:@heavyFlavor")}, stepDict[step][k]]) + else: + stepDict[stepName][k] = merge([{'-s': thisStep + ",DQM:@heavyFlavor"}, stepDict[step][k]]) + + def condition(self, fragment, stepList, key, hasHarvest): + return any(frag in fragment for frag in self.__frags) + +upgradeWFs['HeavyFlavor'] = UpgradeWorkflow_HeavyFlavor( + steps = [ + 'Reco', + 'RecoNano' + ], + PU = [], + suffix = '_HeavyFlavor', + offset = 0.81, +) + class UpgradeWorkflow_JMENano(UpgradeWorkflow): def setup_(self, step, stepName, stepDict, k, properties): if 'Nano' in step: diff --git a/Configuration/PyReleaseValidation/scripts/runTheMatrix.py b/Configuration/PyReleaseValidation/scripts/runTheMatrix.py index 91162e6b70e92..69323c2a106cf 100755 --- a/Configuration/PyReleaseValidation/scripts/runTheMatrix.py +++ b/Configuration/PyReleaseValidation/scripts/runTheMatrix.py @@ -97,8 +97,8 @@ def runSelected(opt): 13234.0, #2021 ttbar fastsim 13434.0, #2021 ttbar PU fastsim 12434.0, #2023 ttbar - 23634.0, #2026D95 ttbar (2023 new baseline) - #23634.911, #2026D95 ttbar DD4hep XML + 23634.0, #2026D95 ttbar (Phase-2 baseline) + 23634.911, #2026D95 ttbar DD4hep XML 23834.999, #2026D95 ttbar premixing stage1+stage2, PU50 23696.0, #CE_E_Front_120um D95 23700.0, #CE_H_Coarse_Scint D95 diff --git a/Configuration/Skimming/python/PDWG_EXOLLPJetHCAL_cff.py b/Configuration/Skimming/python/PDWG_EXOLLPJetHCAL_cff.py new file mode 100644 index 0000000000000..540c3e30bb158 --- /dev/null +++ b/Configuration/Skimming/python/PDWG_EXOLLPJetHCAL_cff.py @@ -0,0 +1,15 @@ +import FWCore.ParameterSet.Config as cms + +import HLTrigger.HLTfilters.hltHighLevel_cfi as _hltHighLevel +hltLLPJetHCAL = _hltHighLevel.hltHighLevel.clone( + throw = False, + andOr = True, + HLTPaths = [ + "HLT*_L1SingleLLPJet_*", + ] +) + +# disappTrk skim sequence +EXOLLPJetHCALSkimSequence = cms.Sequence( + hltLLPJetHCAL + ) \ No newline at end of file diff --git a/Configuration/Skimming/python/Skims_PDWG_cff.py b/Configuration/Skimming/python/Skims_PDWG_cff.py index 93575f538756a..0ab2334456d3e 100644 --- a/Configuration/Skimming/python/Skims_PDWG_cff.py +++ b/Configuration/Skimming/python/Skims_PDWG_cff.py @@ -293,6 +293,17 @@ dataTier = cms.untracked.string('AOD') ) +from Configuration.Skimming.PDWG_EXOLLPJetHCAL_cff import * +EXOLLPJetHCALPath = cms.Path(EXOLLPJetHCALSkimSequence) +SKIMStreamEXOLLPJetHCAL = cms.FilteredStream( + responsible = 'PDWG', + name = 'EXOLLPJetHCAL', + paths = (EXOLLPJetHCALPath), + content = skimRawAODContent.outputCommands+['keep *_hbhereco__*'], + selectEvents = cms.untracked.PSet(), + dataTier = cms.untracked.string('AOD') + ) + from Configuration.Skimming.PDWG_EXODTCluster_cff import * EXODTClusterPath = cms.Path(EXODTClusterSkimSequence) SKIMStreamEXODTCluster = cms.FilteredStream( diff --git a/Configuration/Skimming/test/test_EXOLLPJetHCAL_SKIM.py b/Configuration/Skimming/test/test_EXOLLPJetHCAL_SKIM.py new file mode 100644 index 0000000000000..57915d7452dd2 --- /dev/null +++ b/Configuration/Skimming/test/test_EXOLLPJetHCAL_SKIM.py @@ -0,0 +1,403 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: skims -s SKIM:EXOLLPJetHCAL --dasquery=file=/store/relval/CMSSW_12_4_11/DisplacedJet/RECO/124X_dataRun3_Prompt_v4_gtval_RelVal_2022D-v1/2580000/1e9b47ed-c192-4f49-9e3d-6fac61586946.root -n 100 --conditions 120X_mcRun3_2021_realistic_v6 --python_filename=test_EXOLLPJetHCAL_SKIM.py --processName=SKIMEXOLLPJetHCAL --no_exec --data +import FWCore.ParameterSet.Config as cms + + + +process = cms.Process('SKIMEXOLLPJetHCAL') + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('Configuration.StandardSequences.Skims_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1000), + output = cms.optional.untracked.allowed(cms.int32,cms.PSet) +) + +# Input source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring('/store/relval/CMSSW_12_4_11/DisplacedJet/RECO/124X_dataRun3_Prompt_v4_gtval_RelVal_2022D-v1/2580000/1e9b47ed-c192-4f49-9e3d-6fac61586946.root'), + secondaryFileNames = cms.untracked.vstring() +) + +process.options = cms.untracked.PSet( + FailPath = cms.untracked.vstring(), + IgnoreCompletely = cms.untracked.vstring(), + Rethrow = cms.untracked.vstring(), + SkipEvent = cms.untracked.vstring(), + accelerators = cms.untracked.vstring('*'), + allowUnscheduled = cms.obsolete.untracked.bool, + canDeleteEarly = cms.untracked.vstring(), + deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), + dumpOptions = cms.untracked.bool(False), + emptyRunLumiMode = cms.obsolete.untracked.string, + eventSetup = cms.untracked.PSet( + forceNumberOfConcurrentIOVs = cms.untracked.PSet( + allowAnyLabel_=cms.required.untracked.uint32 + ), + numberOfConcurrentIOVs = cms.untracked.uint32(0) + ), + fileMode = cms.untracked.string('FULLMERGE'), + forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), + holdsReferencesToDeleteEarly = cms.untracked.VPSet(), + makeTriggerResults = cms.obsolete.untracked.bool, + modulesToIgnoreForDeleteEarly = cms.untracked.vstring(), + numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), + numberOfConcurrentRuns = cms.untracked.uint32(1), + numberOfStreams = cms.untracked.uint32(0), + numberOfThreads = cms.untracked.uint32(1), + printDependencies = cms.untracked.bool(False), + sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, + throwIfIllegalParameter = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(False) +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('skims nevts:100'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Output definition + +process.RECOSIMoutput = cms.OutputModule("PoolOutputModule", + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string(''), + filterName = cms.untracked.string('') + ), + fileName = cms.untracked.string('skims_SKIM.root'), + outputCommands = process.RECOSIMEventContent.outputCommands, + splitLevel = cms.untracked.int32(0) +) + +# Additional output definition +process.SKIMStreamEXOLLPJetHCAL = cms.OutputModule("PoolOutputModule", + SelectEvents = cms.untracked.PSet( + SelectEvents = cms.vstring('EXOLLPJetHCALPath') + ), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('AOD'), + filterName = cms.untracked.string('EXOLLPJetHCAL') + ), + eventAutoFlushCompressedSize = cms.untracked.int32(5242880), + fileName = cms.untracked.string('EXOLLPJetHCAL.root'), + outputCommands = cms.untracked.vstring( ( + 'drop *', + 'drop *', + 'keep ClusterSummary_clusterSummaryProducer_*_*', + 'keep *_dt4DSegments_*_*', + 'keep *_dt4DCosmicSegments_*_*', + 'keep *_cscSegments_*_*', + 'keep *_rpcRecHits_*_*', + 'keep *_dt1DRecHits_*_*', + 'keep *_csc2DRecHits_*_*', + 'keep *_castorreco_*_*', + 'keep *_reducedHcalRecHits_*_*', + 'keep HcalUnpackerReport_castorDigis_*_*', + 'keep HcalUnpackerReport_hcalDigiAlCaMB_*_*', + 'keep HcalUnpackerReport_hcalDigis_*_*', + 'keep *_selectDigi_*_*', + 'keep EcalRecHitsSorted_reducedEcalRecHitsEB_*_*', + 'keep EcalRecHitsSorted_reducedEcalRecHitsEE_*_*', + 'keep EcalRecHitsSorted_reducedEcalRecHitsES_*_*', + 'keep recoSuperClusters_correctedHybridSuperClusters_*_*', + 'keep recoCaloClusters_hybridSuperClusters_*_*', + 'keep recoSuperClusters_hybridSuperClusters_uncleanOnlyHybridSuperClusters_*', + 'keep recoCaloClusters_multi5x5SuperClusters_multi5x5EndcapBasicClusters_*', + 'keep recoSuperClusters_correctedMulti5x5SuperClustersWithPreshower_*_*', + 'keep recoPreshowerClusters_multi5x5SuperClustersWithPreshower_*_*', + 'keep recoPreshowerClusterShapes_multi5x5PreshowerClusterShape_*_*', + 'keep recoSuperClusters_particleFlowSuperClusterECAL_*_*', + 'keep recoCaloClusters_particleFlowSuperClusterECAL_*_*', + 'keep recoSuperClusters_particleFlowSuperClusterOOTECAL_*_*', + 'keep recoCaloClusters_particleFlowSuperClusterOOTECAL_*_*', + 'keep recoTracks_GsfGlobalElectronTest_*_*', + 'keep recoGsfTracks_electronGsfTracks_*_*', + 'keep recoTracks_generalTracks_*_*', + 'keep recoTracks_conversionStepTracks_*_*', + 'keep recoTracks_beamhaloTracks_*_*', + 'keep recoTracks_ctfPixelLess_*_*', + 'keep *_dedxHarmonic2_*_*', + 'keep *_dedxPixelHarmonic2_*_*', + 'keep *_dedxHitInfo_*_*', + 'keep *_trackExtrapolator_*_*', + 'keep *_generalTracks_MVAValues_*', + 'keep *_generalTracks_MVAVals_*', + 'keep recoCaloJets_ak4CaloJets_*_*', + 'keep *_ak4CaloJets_rho_*', + 'keep *_ak4CaloJets_sigma_*', + 'keep *_ak4PFJetsCHS_*_*', + 'keep floatedmValueMap_puppi_*_*', + 'keep *_ak4PFJetsPuppi_*_*', + 'keep *_ak8PFJetsPuppi_*_*', + 'keep *_ak8PFJetsPuppiSoftDrop_*_*', + 'keep recoPFJets_ak4PFJets_*_*', + 'keep *_ak4PFJets_rho_*', + 'keep *_ak4PFJets_sigma_*', + 'keep *_JetPlusTrackZSPCorJetAntiKt4_*_*', + 'keep *_caloTowers_*_*', + 'keep *_CastorTowerReco_*_*', + 'keep *_ak4JetTracksAssociatorAtVertex_*_*', + 'keep *_ak4JetTracksAssociatorAtVertexPF_*_*', + 'keep *_ak4JetTracksAssociatorExplicit_*_*', + 'keep *_ak4JetExtender_*_*', + 'keep *_ak4JetID_*_*', + 'keep recoBasicJets_ak5CastorJets_*_*', + 'keep *_ak5CastorJets_rho_*', + 'keep *_ak5CastorJets_sigma_*', + 'keep *_ak5CastorJetID_*_*', + 'keep recoBasicJets_ak7CastorJets_*_*', + 'keep *_ak7CastorJets_rho_*', + 'keep *_ak7CastorJets_sigma_*', + 'keep *_ak7CastorJetID_*_*', + 'keep *_fixedGridRhoAll_*_*', + 'keep *_fixedGridRhoFastjetAll_*_*', + 'keep *_fixedGridRhoFastjetAllTmp_*_*', + 'keep *_fixedGridRhoFastjetCentral_*_*', + 'keep *_fixedGridRhoFastjetAllCalo_*_*', + 'keep *_fixedGridRhoFastjetCentralCalo_*_*', + 'keep *_fixedGridRhoFastjetCentralChargedPileUp_*_*', + 'keep *_fixedGridRhoFastjetCentralNeutral_*_*', + 'keep *_ak8PFJetsPuppiSoftDropMass_*_*', + 'keep recoCaloMETs_caloMet_*_*', + 'keep recoCaloMETs_caloMetBE_*_*', + 'keep recoCaloMETs_caloMetBEFO_*_*', + 'keep recoCaloMETs_caloMetM_*_*', + 'keep recoPFMETs_pfMet_*_*', + 'keep recoPFMETs_pfChMet_*_*', + 'keep floatedmValueMap_puppiNoLep_*_*', + 'keep recoPFMETs_pfMetPuppi_*_*', + 'keep recoMuonMETCorrectionDataedmValueMap_muonMETValueMapProducer_*_*', + 'keep HcalNoiseSummary_hcalnoise_*_*', + 'keep recoGlobalHaloData_GlobalHaloData_*_*', + 'keep recoCSCHaloData_CSCHaloData_*_*', + 'keep recoBeamHaloSummary_BeamHaloSummary_*_*', + 'keep recoMuons_muons_*_*', + 'keep booledmValueMap_muons_*_*', + 'keep doubleedmValueMap_muons_muPFMean*_*', + 'keep doubleedmValueMap_muons_muPFSum*_*', + 'keep *_muons_muonShowerInformation_*', + 'keep recoMuonTimeExtraedmValueMap_muons_*_*', + 'keep recoMuonCosmicCompatibilityedmValueMap_muons_*_*', + 'keep uintedmValueMap_muons_*_*', + 'keep *_particleFlow_muons_*', + 'keep recoMuons_displacedMuons_*_*', + 'keep booledmValueMap_displacedMuons_*_*', + 'keep doubleedmValueMap_displacedMuons_dispMuPFMean*_*', + 'keep doubleedmValueMap_displacedMuons_dispMuPFSum*_*', + 'keep recoMuonTimeExtraedmValueMap_displacedMuons_*_*', + 'keep uintedmValueMap_displacedMuons_*_*', + 'keep *_particleFlow_displacedMuons_*', + 'keep recoTracks_standAloneMuons_*_*', + 'keep recoTrackExtras_standAloneMuons_*_*', + 'keep TrackingRecHitsOwned_standAloneMuons_*_*', + 'keep recoTracks_globalMuons_*_*', + 'keep recoTrackExtras_globalMuons_*_*', + 'keep recoTracks_tevMuons_*_*', + 'keep recoTrackExtras_tevMuons_*_*', + 'keep recoTracks_generalTracks_*_*', + 'keep recoTracks_displacedTracks_*_*', + 'keep recoTracksToOnerecoTracksAssociation_tevMuons_*_*', + 'keep recoTracks_displacedGlobalMuons_*_*', + 'keep recoTrackExtras_displacedGlobalMuons_*_*', + 'keep TrackingRecHitsOwned_displacedGlobalMuons_*_*', + 'keep recoTracks_cosmicMuons_*_*', + 'keep recoMuons_muonsFromCosmics_*_*', + 'keep recoTracks_cosmicMuons1Leg_*_*', + 'keep recoMuons_muonsFromCosmics1Leg_*_*', + 'keep recoTracks_refittedStandAloneMuons_*_*', + 'keep recoTrackExtras_refittedStandAloneMuons_*_*', + 'keep TrackingRecHitsOwned_refittedStandAloneMuons_*_*', + 'keep recoTracks_displacedStandAloneMuons__*', + 'keep recoTrackExtras_displacedStandAloneMuons_*_*', + 'keep TrackingRecHitsOwned_displacedStandAloneMuons_*_*', + 'keep *_muonReducedTrackExtras_*_*', + 'keep *_displacedMuonReducedTrackExtras_*_*', + 'keep *_softPFElectronBJetTags_*_*', + 'keep *_softPFMuonBJetTags_*_*', + 'keep *_pfTrackCountingHighEffBJetTags_*_*', + 'keep *_pfJetProbabilityBJetTags_*_*', + 'keep *_pfJetBProbabilityBJetTags_*_*', + 'keep *_pfSimpleSecondaryVertexHighEffBJetTags_*_*', + 'keep *_pfSimpleInclusiveSecondaryVertexHighEffBJetTags_*_*', + 'keep *_pfCombinedSecondaryVertexV2BJetTags_*_*', + 'keep *_pfCombinedInclusiveSecondaryVertexV2BJetTags_*_*', + 'keep *_pfGhostTrackBJetTags_*_*', + 'keep *_pfCombinedMVAV2BJetTags_*_*', + 'keep *_inclusiveCandidateSecondaryVertices_*_*', + 'keep *_inclusiveCandidateSecondaryVerticesCvsL_*_*', + 'keep *_pfCombinedCvsLJetTags_*_*', + 'keep *_pfCombinedCvsBJetTags_*_*', + 'keep *_pfChargeBJetTags_*_*', + 'keep *_pfDeepCSVJetTags_*_*', + 'keep *_pfDeepCMVAJetTags_*_*', + 'keep *_pixelClusterTagInfos_*_*', + 'keep recoRecoTauPiZeros_hpsPFTauProducer_pizeros_*', + 'keep recoPFTaus_hpsPFTauProducer_*_*', + 'keep *_hpsPFTauBasicDiscriminators_*_*', + 'keep *_hpsPFTauBasicDiscriminatorsdR03_*_*', + 'keep *_hpsPFTauDiscriminationByDeadECALElectronRejection_*_*', + 'keep *_hpsPFTauDiscriminationByDecayModeFinding_*_*', + 'keep *_hpsPFTauDiscriminationByDecayModeFindingNewDMs_*_*', + 'keep *_hpsPFTauDiscriminationByDecayModeFindingOldDMs_*_*', + 'keep *_hpsPFTauDiscriminationByMuonRejection3_*_*', + 'keep *_hpsPFTauTransverseImpactParameters_*_*', + 'keep *_offlinePrimaryVertices__*', + 'keep *_offlinePrimaryVerticesWithBS_*_*', + 'keep *_offlinePrimaryVerticesFromCosmicTracks_*_*', + 'keep *_nuclearInteractionMaker_*_*', + 'keep *_generalV0Candidates_*_*', + 'keep *_inclusiveSecondaryVertices_*_*', + 'keep recoGsfElectronCores_gsfElectronCores_*_*', + 'keep recoGsfElectronCores_gedGsfElectronCores_*_*', + 'keep recoGsfElectrons_gsfElectrons_*_*', + 'keep recoGsfElectrons_gedGsfElectrons_*_*', + 'keep recoGsfElectronCores_uncleanedOnlyGsfElectronCores_*_*', + 'keep recoGsfElectrons_uncleanedOnlyGsfElectrons_*_*', + 'keep floatedmValueMap_eidRobustLoose_*_*', + 'keep floatedmValueMap_eidRobustTight_*_*', + 'keep floatedmValueMap_eidRobustHighEnergy_*_*', + 'keep floatedmValueMap_eidLoose_*_*', + 'keep floatedmValueMap_eidTight_*_*', + 'keep *_egmGedGsfElectronPFIsolation_*_*', + 'keep recoPhotonCores_gedPhotonCore_*_*', + 'keep recoPhotons_gedPhotons_*_*', + 'keep *_particleBasedIsolation_*_*', + 'keep recoPhotonCores_photonCore_*_*', + 'keep recoPhotons_photons_*_*', + 'keep recoPhotonCores_ootPhotonCore_*_*', + 'keep recoPhotons_ootPhotons_*_*', + 'keep recoConversions_conversions_*_*', + 'drop recoConversions_conversions_uncleanedConversions_*', + 'keep recoConversions_mustacheConversions_*_*', + 'keep *_gsfTracksOpenConversions_*_*', + 'keep recoConversions_allConversions_*_*', + 'keep recoConversions_allConversionsOldEG_*_*', + 'keep recoTracks_ckfOutInTracksFromConversions_*_*', + 'keep recoTracks_ckfInOutTracksFromConversions_*_*', + 'keep recoConversions_uncleanedOnlyAllConversions_*_*', + 'keep recoTracks_uncleanedOnlyCkfOutInTracksFromConversions_*_*', + 'keep recoTracks_uncleanedOnlyCkfInOutTracksFromConversions_*_*', + 'keep *_PhotonIDProd_*_*', + 'keep *_PhotonIDProdGED_*_*', + 'keep *_hfRecoEcalCandidate_*_*', + 'keep *_hfEMClusters_*_*', + 'keep *_gedGsfElectronCores_*_*', + 'keep *_gedGsfElectrons_*_*', + 'keep recoCaloClusters_lowPtGsfElectronSuperClusters_*_*', + 'keep recoGsfElectrons_lowPtGsfElectrons_*_*', + 'keep recoGsfElectronCores_lowPtGsfElectronCores_*_*', + 'keep recoGsfTracks_lowPtGsfEleGsfTracks_*_*', + 'keep *_lowPtGsfToTrackLinks_*_*', + 'keep recoSuperClusters_lowPtGsfElectronSuperClusters_*_*', + 'keep floatedmValueMap_lowPtGsfElectronSeedValueMaps_*_*', + 'keep floatedmValueMap_rekeyLowPtGsfElectronSeedValueMaps_*_*', + 'keep floatedmValueMap_lowPtGsfElectronID_*_*', + 'keep recoPFRecHits_particleFlowRecHitECAL_Cleaned_*', + 'keep recoPFRecHits_particleFlowRecHitHBHE_Cleaned_*', + 'keep recoPFRecHits_particleFlowRecHitHF_Cleaned_*', + 'keep recoPFRecHits_particleFlowRecHitHO_Cleaned_*', + 'keep recoPFRecHits_particleFlowRecHitPS_Cleaned_*', + 'keep recoCaloClusters_particleFlowEGamma_*_*', + 'keep recoSuperClusters_particleFlowEGamma_*_*', + 'keep recoCaloClusters_particleFlowSuperClusterECAL_*_*', + 'keep recoSuperClusters_particleFlowSuperClusterECAL_*_*', + 'keep recoConversions_particleFlowEGamma_*_*', + 'keep recoPFCandidates_particleFlow_*_*', + 'keep recoPFCandidates_particleFlowTmp_AddedMuonsAndHadrons_*', + 'keep recoPFCandidates_particleFlowTmp_CleanedCosmicsMuons_*', + 'keep recoPFCandidates_particleFlowTmp_CleanedFakeMuons_*', + 'keep recoPFCandidates_particleFlowTmp_CleanedHF_*', + 'keep recoPFCandidates_particleFlowTmp_CleanedPunchThroughMuons_*', + 'keep recoPFCandidates_particleFlowTmp_CleanedPunchThroughNeutralHadrons_*', + 'keep recoPFCandidates_particleFlowTmp_CleanedTrackerAndGlobalMuons_*', + 'keep *_particleFlow_electrons_*', + 'keep *_particleFlow_photons_*', + 'keep *_particleFlow_muons_*', + 'keep recoCaloClusters_pfElectronTranslator_*_*', + 'keep recoPreshowerClusters_pfElectronTranslator_*_*', + 'keep recoSuperClusters_pfElectronTranslator_*_*', + 'keep recoCaloClusters_pfPhotonTranslator_*_*', + 'keep recoPreshowerClusters_pfPhotonTranslator_*_*', + 'keep recoSuperClusters_pfPhotonTranslator_*_*', + 'keep recoPhotons_pfPhotonTranslator_*_*', + 'keep recoPhotonCores_pfPhotonTranslator_*_*', + 'keep recoConversions_pfPhotonTranslator_*_*', + 'keep *_particleFlowPtrs_*_*', + 'keep *_particleFlowTmpPtrs_*_*', + 'keep *_chargedHadronPFTrackIsolation_*_*', + 'keep *_offlineBeamSpot_*_*', + 'keep L1GlobalTriggerReadoutRecord_gtDigis_*_*', + 'keep *_l1GtRecord_*_*', + 'keep *_l1GtTriggerMenuLite_*_*', + 'keep *_conditionsInEdm_*_*', + 'keep *_l1extraParticles_*_*', + 'keep *_l1L1GtObjectMap_*_*', + 'keep LumiSummary_lumiProducer_*_*', + 'drop *_hlt*_*_*', + 'keep GlobalObjectMapRecord_hltGtStage2ObjectMap_*_*', + 'keep edmTriggerResults_*_*_*', + 'keep triggerTriggerEvent_*_*_*', + 'keep *_hltFEDSelectorL1_*_*', + 'keep *_hltScoutingEgammaPacker_*_*', + 'keep *_hltScoutingMuonPacker_*_*', + 'keep *_hltScoutingPFPacker_*_*', + 'keep *_hltScoutingPrimaryVertexPacker_*_*', + 'keep *_hltScoutingTrackPacker_*_*', + 'keep edmTriggerResults_*_*_*', + 'keep L1AcceptBunchCrossings_scalersRawToDigi_*_*', + 'keep L1TriggerScalerss_scalersRawToDigi_*_*', + 'keep Level1TriggerScalerss_scalersRawToDigi_*_*', + 'keep LumiScalerss_scalersRawToDigi_*_*', + 'keep BeamSpotOnlines_scalersRawToDigi_*_*', + 'keep DcsStatuss_scalersRawToDigi_*_*', + 'keep CTPPSRecord_onlineMetaDataDigis_*_*', + 'keep DCSRecord_onlineMetaDataDigis_*_*', + 'keep OnlineLuminosityRecord_onlineMetaDataDigis_*_*', + 'keep recoBeamSpot_onlineMetaDataDigis_*_*', + 'keep *_tcdsDigis_*_*', + 'keep *_logErrorHarvester_*_*', + 'keep FEDRawDataCollection_rawDataCollector_*_*', + 'keep FEDRawDataCollection_source_*_*', + 'drop *_MEtoEDMConverter_*_*', + 'drop *_*_*_SKIM', + 'keep *_hbhereco__*' + ) ) +) + +# Other statements +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, '120X_mcRun3_2021_realistic_v6', '') + +# Path and EndPath definitions +process.RECOSIMoutput_step = cms.EndPath(process.RECOSIMoutput) +process.SKIMStreamEXOLLPJetHCALOutPath = cms.EndPath(process.SKIMStreamEXOLLPJetHCAL) + +# Schedule definition +process.schedule = cms.Schedule(process.EXOLLPJetHCALPath,process.RECOSIMoutput_step,process.SKIMStreamEXOLLPJetHCALOutPath) +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) + + + +# Customisation from command line + +#Have logErrorHarvester wait for the same EDProducers to finish as those providing data for the OutputModule +from FWCore.Modules.logErrorHarvester_cff import customiseLogErrorHarvesterUsingOutputCommands +process = customiseLogErrorHarvesterUsingOutputCommands(process) + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion diff --git a/DQM/Integration/test/BuildFile.xml b/DQM/Integration/test/BuildFile.xml index 70efac6554c41..bfd02a4c970c0 100644 --- a/DQM/Integration/test/BuildFile.xml +++ b/DQM/Integration/test/BuildFile.xml @@ -1,6 +1,3 @@ - - - diff --git a/DataFormats/FWLite/test/test.cppunit.cpp b/DataFormats/FWLite/test/test.cppunit.cpp index 873043639b073..58cd14ded3f7d 100644 --- a/DataFormats/FWLite/test/test.cppunit.cpp +++ b/DataFormats/FWLite/test/test.cppunit.cpp @@ -14,7 +14,6 @@ Test program for edm::Ref use in ROOT. #include "DataFormats/TestObjects/interface/OtherThingCollection.h" #include "DataFormats/TestObjects/interface/ThingCollection.h" #include "DataFormats/TestObjects/interface/TrackOfThings.h" -#include "FWCore/Utilities/interface/TestHelper.h" #include "DataFormats/FWLite/interface/ChainEvent.h" #include "DataFormats/FWLite/interface/EventBase.h" @@ -23,12 +22,6 @@ Test program for edm::Ref use in ROOT. #include "DataFormats/Common/interface/Handle.h" #include "DataFormats/Provenance/interface/ProductID.h" -static char* gArgV = nullptr; - -extern "C" char** environ; - -#define CHARSTAR(x) const_cast(x) - class testRefInROOT : public CppUnit::TestFixture { CPPUNIT_TEST_SUITE(testRefInROOT); @@ -576,10 +569,7 @@ void testRefInROOT::testThinning() { #include #include -int main(int argc, char* argv[]) { - gArgV = argv[0]; - std::string testPath = (argc > 1) ? std::string(argv[1]) : ""; - +int main() { // Create the event manager and test controller CppUnit::TestResult controller; @@ -595,8 +585,8 @@ int main(int argc, char* argv[]) { CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); try { - std::cout << "Running " << testPath; - runner.run(controller, testPath); + std::cout << "Running "; + runner.run(controller); std::cerr << std::endl; diff --git a/DataFormats/L1TMuonPhase2/interface/Constants.h b/DataFormats/L1TMuonPhase2/interface/Constants.h index d3f80a3421948..ea8c2f4c0c5cb 100644 --- a/DataFormats/L1TMuonPhase2/interface/Constants.h +++ b/DataFormats/L1TMuonPhase2/interface/Constants.h @@ -54,7 +54,7 @@ namespace Phase2L1GMT { // Bitwidth for standalone muons to CL1 and GT const int BITSSAZ0 = 5; const int BITSSAD0 = 7; - const int BITSSAQUALITY = 4; + const int BITSSAQUAL = 4; // Bitwidth for dataformat to GT const int BITSGTPT = 16; @@ -62,14 +62,24 @@ namespace Phase2L1GMT { const int BITSGTETA = 14; const int BITSGTZ0 = 10; const int BITSGTD0 = 10; - const int BITSGTQUALITY = 8; + const int BITSGTQUAL = 8; const int BITSGTISO = 4; + const int BITSGTBETA = 4; + + // Bitwidth for Tau->3mu object + const int BITSTMPT = 8; + const int BITSTMPHI = 8; + const int BITSTMETA = 8; + const int BITSTMMASS2 = 8; + const int BITSTMTYPE = 6; + const int BITSTMIDX = 4; + const int BITSTMQUAL = 4; const float maxCurv_ = 0.00855; // 2 GeV pT Rinv is in cm const float maxPhi_ = 1.026; // relative to the center of the sector const float maxTanl_ = 8.0; - const float maxZ0_ = 30.; - const float maxD0_ = 15.4; + const float maxZ0_ = 25.6; + const float maxD0_ = 15.36; // Updated barrelLimit according to Karol, https://indico.cern.ch/event/1113802/#1-phase2-gmt-performance-and-i const int barrelLimit0_ = 1.4 / 0.00076699039 / 8; const int barrelLimit1_ = 1.1 / 0.00076699039 / 8; @@ -81,12 +91,32 @@ namespace Phase2L1GMT { const float LSBpt = 0.03125; const float LSBphi = 2. * M_PI / pow(2, BITSPHI); const float LSBeta = 2. * M_PI / pow(2, BITSETA); - const float LSBGTz0 = 2. * maxZ0_ / pow(2, BITSZ0); - const float LSBGTd0 = 2. * maxD0_ / pow(2, BITSD0); - const float LSBSAz0 = 1.875; - const float LSBSAd0 = 3.85; + const float LSBGTz0 = 0.05; // 0.5mm, in sync with GTT and Correlator + const float LSBGTd0 = 0.03; // from GT interface doc + const float LSBSAz0 = 1.6; // 0.05 * 32 cm, with range +- 25.6 + const float LSBSAd0 = 3.84; // 0.03 * 128 cm, with range +- 245.76 typedef ap_uint<64> wordtype; + typedef ap_uint<1> valid_gt_t; //valid + typedef ap_uint<1> q_gt_t; //charge + typedef ap_uint pt_gt_t; //pt of tracker muon + typedef ap_int phi_gt_t; //phi of tracker muon + typedef ap_int eta_gt_t; //eta of tracker muon + typedef ap_int z0_gt_t; //z0 of tracker muon + typedef ap_int d0_gt_t; //d0 of tracker muon + typedef ap_uint iso_gt_t; //isolation of tracker muon + typedef ap_uint beta_gt_t; //beta of tracker muon + typedef ap_uint qual_gt_t; //quality of tracker muon + + //Standalone muon datatype + typedef ap_uint<1> valid_sa_t; //valid + typedef ap_uint pt_sa_t; //pt of standalone muon + typedef ap_int phi_sa_t; //phi of standalone muon + typedef ap_int eta_sa_t; //eta of standalone muon + typedef ap_int z0_sa_t; //z0 of standalone muon + typedef ap_int d0_sa_t; //d0 of standalone muon + typedef ap_uint<1> q_sa_t; //charge of standalone muon + typedef ap_uint qual_sa_t; //quality of standalone muon inline uint64_t twos_complement(long long int v, uint bits) { uint64_t mask = (1 << bits) - 1; diff --git a/DataFormats/L1TMuonPhase2/interface/SAMuon.h b/DataFormats/L1TMuonPhase2/interface/SAMuon.h index d46d6cab3610c..12ea802dae04f 100644 --- a/DataFormats/L1TMuonPhase2/interface/SAMuon.h +++ b/DataFormats/L1TMuonPhase2/interface/SAMuon.h @@ -31,6 +31,16 @@ namespace l1t { const uint hwBeta() const { return hwBeta_; } void setBeta(uint beta) { hwBeta_ = beta; } + // For GT, returning ap_ type + const Phase2L1GMT::valid_sa_t apValid() const { return Phase2L1GMT::valid_sa_t(hwPt() > 0); }; + const Phase2L1GMT::pt_sa_t apPt() const { return Phase2L1GMT::pt_sa_t(hwPt()); }; + const Phase2L1GMT::phi_sa_t apPhi() const { return Phase2L1GMT::phi_sa_t(hwPhi()); }; + const Phase2L1GMT::eta_sa_t apEta() const { return Phase2L1GMT::eta_sa_t(hwEta()); }; + const Phase2L1GMT::z0_sa_t apZ0() const { return Phase2L1GMT::z0_sa_t(hwZ0()); }; + const Phase2L1GMT::d0_sa_t apD0() const { return Phase2L1GMT::d0_sa_t(hwD0()); }; + const Phase2L1GMT::q_sa_t apCharge() const { return Phase2L1GMT::q_sa_t(hwCharge()); }; + const Phase2L1GMT::qual_sa_t apQual() const { return Phase2L1GMT::qual_sa_t(hwQual()); }; + // For HLT const double phZ0() const { return Phase2L1GMT::LSBSAz0 * hwZ0(); } const double phD0() const { return Phase2L1GMT::LSBSAd0 * hwD0(); } diff --git a/DataFormats/L1TMuonPhase2/interface/TrackerMuon.h b/DataFormats/L1TMuonPhase2/interface/TrackerMuon.h index 78bb288685d37..1dd8cc90bf344 100644 --- a/DataFormats/L1TMuonPhase2/interface/TrackerMuon.h +++ b/DataFormats/L1TMuonPhase2/interface/TrackerMuon.h @@ -32,7 +32,7 @@ namespace l1t { ~TrackerMuon() override; const edm::Ptr& trkPtr() const { return trkPtr_; } - const edm::Ref& muonRef() const { return muRef_; } + const std::vector& muonRef() const { return muRef_; } const bool hwCharge() const { return hwCharge_; } const int hwZ0() const { return hwZ0_; } @@ -41,10 +41,22 @@ namespace l1t { const int hwIsoSumAp() const { return hwIsoSumAp_; } const uint hwBeta() const { return hwBeta_; } void setBeta(uint beta) { hwBeta_ = beta; } - void setMuonRef(const edm::Ref& p) { muRef_ = p; } + void setMuonRef(const std::vector& p) { muRef_ = p; } void setHwIsoSum(int isoSum) { hwIsoSum_ = isoSum; } void setHwIsoSumAp(int isoSum) { hwIsoSumAp_ = isoSum; } + // For GT, returning ap_ type + const Phase2L1GMT::valid_gt_t apValid() const { return Phase2L1GMT::valid_gt_t(hwPt() > 0); }; + const Phase2L1GMT::pt_gt_t apPt() const { return Phase2L1GMT::pt_gt_t(hwPt()); }; + const Phase2L1GMT::phi_gt_t apPhi() const { return Phase2L1GMT::phi_gt_t(hwPhi()); }; + const Phase2L1GMT::eta_gt_t apEta() const { return Phase2L1GMT::eta_gt_t(hwEta()); }; + const Phase2L1GMT::z0_gt_t apZ0() const { return Phase2L1GMT::z0_gt_t(hwZ0()); }; + const Phase2L1GMT::d0_gt_t apD0() const { return Phase2L1GMT::d0_gt_t(hwD0()); }; + const Phase2L1GMT::q_gt_t apCharge() const { return Phase2L1GMT::q_gt_t(hwCharge()); }; + const Phase2L1GMT::qual_gt_t apQual() const { return Phase2L1GMT::qual_gt_t(hwQual()); }; + const Phase2L1GMT::iso_gt_t apIso() const { return Phase2L1GMT::iso_gt_t(hwIso()); }; + const Phase2L1GMT::beta_gt_t apBeta() const { return Phase2L1GMT::beta_gt_t(hwBeta()); }; + // For HLT const double phZ0() const { return Phase2L1GMT::LSBGTz0 * hwZ0(); } const double phD0() const { return Phase2L1GMT::LSBGTd0 * hwD0(); } @@ -76,7 +88,7 @@ namespace l1t { //Store the eneryg sum for isolation with ap_type int hwIsoSumAp_; - edm::Ref muRef_; + std::vector muRef_; MuonStubRefVector stubs_; }; } // namespace l1t diff --git a/DataFormats/L1TMuonPhase2/src/classes_def.xml b/DataFormats/L1TMuonPhase2/src/classes_def.xml index b20feacd4c091..b3cbf00fcf430 100644 --- a/DataFormats/L1TMuonPhase2/src/classes_def.xml +++ b/DataFormats/L1TMuonPhase2/src/classes_def.xml @@ -8,7 +8,8 @@ - + + diff --git a/FWCore/FWLite/test/BuildFile.xml b/FWCore/FWLite/test/BuildFile.xml index d9b36bfa5240b..1035cac14234b 100644 --- a/FWCore/FWLite/test/BuildFile.xml +++ b/FWCore/FWLite/test/BuildFile.xml @@ -1,7 +1,10 @@ + + + diff --git a/FWCore/FWLite/test/ref_t.cppunit.cpp b/FWCore/FWLite/test/ref_t.cppunit.cpp index 1669f372be38a..865be3ca8e929 100644 --- a/FWCore/FWLite/test/ref_t.cppunit.cpp +++ b/FWCore/FWLite/test/ref_t.cppunit.cpp @@ -62,13 +62,6 @@ using ROOT's "Draw" interface. #include "DataFormats/TestObjects/interface/OtherThingCollection.h" #include "DataFormats/TestObjects/interface/TrackOfThings.h" #include "DataFormats/Provenance/interface/BranchType.h" -#include "FWCore/Utilities/interface/TestHelper.h" - -static char* gArgV = nullptr; - -extern "C" char** environ; - -#define CHARSTAR(x) const_cast(x) class testRefInROOT : public CppUnit::TestFixture { CPPUNIT_TEST_SUITE(testRefInROOT); @@ -93,14 +86,6 @@ class testRefInROOT : public CppUnit::TestFixture { if (!sWasRun_) { gSystem->Load("libFWCoreFWLite.so"); FWLiteEnabler::enable(); - - char* argv[] = { - CHARSTAR("testFWCoreFWLite"), CHARSTAR("/bin/bash"), CHARSTAR("FWCore/FWLite/test"), CHARSTAR("RefTest.sh")}; - argv[0] = gArgV; - if (0 != ptomaine(sizeof(argv) / sizeof(const char*), argv, environ)) { - std::cerr << "could not run script needed to make test files\n"; - ::exit(-1); - } sWasRun_ = true; } } @@ -494,10 +479,7 @@ void testRefInROOT::testThinning() { #include #include -int main(int argc, char* argv[]) { - gArgV = argv[0]; - std::string testPath = (argc > 1) ? std::string(argv[1]) : ""; - +int main() { // Create the event manager and test controller CppUnit::TestResult controller; @@ -513,8 +495,8 @@ int main(int argc, char* argv[]) { CppUnit::TestRunner runner; runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest()); try { - std::cout << "Running " << testPath; - runner.run(controller, testPath); + std::cout << "Running "; + runner.run(controller); std::cerr << std::endl; diff --git a/FWCore/Services/test/BuildFile.xml b/FWCore/Services/test/BuildFile.xml index dab99a16e1a63..61df66283d06c 100644 --- a/FWCore/Services/test/BuildFile.xml +++ b/FWCore/Services/test/BuildFile.xml @@ -14,11 +14,12 @@ + + + + - - - diff --git a/FWCore/Utilities/interface/TestHelper.h b/FWCore/Utilities/interface/TestHelper.h deleted file mode 100644 index 7768da00522de..0000000000000 --- a/FWCore/Utilities/interface/TestHelper.h +++ /dev/null @@ -1,33 +0,0 @@ -#ifndef Utilities_TestHelper -#define Utilities_TestHelper -// -*- C++ -*- - -//------------------------------------------------------------ -// -// Function to drive test programs and scripts. -// -// Write your test program with whatever name you want; the -// implementation should be: -// -// int main(int argc, char* argv[]) { return ptomaine(argc, argv); } -// -// -// Asumming you call your program RunThis, invocation of this program -// should look like: -// -// RunThis [args ...] -// e.g. -// RunThis /bin/bash ls -// RunThis /bin/bash cmsRun -p somefile.cfg -// RunThis /bin/bash some_script.sh a b c -// -// -//------------------------------------------------------------ - -int ptomaine(int argc, char* argv[], char** env); - -#define RUNTEST() \ - extern "C" char** environ; \ - int main(int argc, char* argv[]) { return ptomaine(argc, argv, environ); } - -#endif diff --git a/FWCore/Utilities/scripts/edmFileInPath b/FWCore/Utilities/scripts/edmFileInPath new file mode 100755 index 0000000000000..bd655e47ab1f4 --- /dev/null +++ b/FWCore/Utilities/scripts/edmFileInPath @@ -0,0 +1,21 @@ +#!/bin/bash +function usage(){ + echo "Usage: $0 [-h|--help] " + echo " $0 CondTools/Hcal/data/hcalpfcuts.txt" + exit $1 +} + + +if [ "$1" = "" ] ; then + echo "ERROR: Mising input data file name" + usage 1 +fi +[ "$1" = "-h" -o "$1" = "--help" ] && usage 0 + +data_file=$1 +for dir in $(echo $CMSSW_SEARCH_PATH | tr ':' '\n') ; do + [ -e $dir/${data_file} ] || continue + echo "$dir/${data_file}" + exit 0 +done +exit 1 diff --git a/FWCore/Utilities/src/TestHelper.cc b/FWCore/Utilities/src/TestHelper.cc deleted file mode 100644 index 7a6d944952bb8..0000000000000 --- a/FWCore/Utilities/src/TestHelper.cc +++ /dev/null @@ -1,192 +0,0 @@ -//------------------------------------------------------------ -//------------------------------------------------------------ -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "FWCore/Utilities/interface/EDMException.h" -#include "FWCore/Utilities/interface/Exception.h" -#include "FWCore/Utilities/interface/RegexMatch.h" -#include "FWCore/Utilities/interface/TestHelper.h" -#include "FWCore/Utilities/interface/thread_safety_macros.h" - -namespace bf = std::filesystem; - -int run_script(std::string const& shell, std::string const& script) { - pid_t pid = 0; - int status = 0; - - if ((pid = fork()) < 0) { - std::cerr << "fork failed, to run " << script << std::endl; - return -1; - } - - if (pid == 0) { // child - execlp(shell.c_str(), "sh", "-c", script.c_str(), static_cast(nullptr)); - std::cerr << "child failed becuase '" << strerror(errno) << "'\n"; - _exit(127); // signal parent and children processes - } else { // parent - while (waitpid(pid, &status, 0) < 0) { - if (errno != EINTR) { - std::cerr << "child process failed " << strerror(errno) << "\n"; - status = -1; - break; - } else { - if (WIFSIGNALED(status)) { - std::cerr << "child existed because of a signal " << WTERMSIG(status) << "\n"; - } - } - } - if (WIFSIGNALED(status)) { - std::cerr << "child existed because of a signal " << WTERMSIG(status) << "\n"; - } - if (WIFEXITED(status)) { - } - } - return status; -} - -int do_work(int argc, char* argv[], char** env) { - bf::path currentPath(bf::current_path().string()); - - if (argc < 4) { - std::cout << "Usage: " << argv[0] << " shell subdir script1 script2 ... scriptN\n\n" - << "where shell is the path+shell (e.g., /bin/bash) intended to run the scripts\n" - << "and subdir is the subsystem/package/subdir in which the scripts are found\n" - << "(e.g., FWCore/Utilities/test)\n" - << std::endl; - - std::cout << "Current directory is: " << currentPath.string() << '\n'; - std::cout << "Current environment:\n"; - std::cout << "---------------------\n"; - for (int i = 0; env[i] != nullptr; ++i) - std::cout << env[i] << '\n'; - std::cout << "---------------------\n"; - std::cout << "Executable name: " << argv[0] << '\n'; - return -1; - } - - char const* goodDirectory = "[A-Za-z0-9/_.-]+"; - - for (int i = 0; i < argc; ++i) { - std::cout << "argument " << i << ": " << argv[i] << '\n'; - } - - std::string shell(argv[1]); - std::cerr << "shell is: " << shell << '\n'; - - std::cout << "Current directory is: " << currentPath.string() << '\n'; - // It is unclear about which of these environment variables should - // be used. - char const* topdir = std::getenv("SCRAMRT_LOCALRT"); - if (!topdir) - topdir = std::getenv("LOCALRT"); - try { - if (!edm::untaintString(topdir, goodDirectory)) { - std::cerr << "Invalid top directory '" << topdir << "'" << std::endl; - return -1; - } - } catch (std::runtime_error const& e) { - std::cerr << "Invalid top directory '" << topdir << "'" << std::endl; - std::cerr << "e.what" << std::endl; - return -1; - } - - char const* arch = std::getenv("SCRAM_ARCH"); - - if (!arch) { - // Try to synthesize SCRAM_ARCH value. - bf::path exepath(argv[0]); - std::string maybe_arch = exepath.parent_path().filename().string(); - - if (setenv("SCRAM_ARCH", maybe_arch.c_str(), 1) != 0) { - std::cerr << "SCRAM_ARCH not set and attempt to set it failed\n"; - return -1; - } - arch = std::getenv("SCRAM_ARCH"); - } - - int rc = 0; - - if (!topdir) { - std::cerr << "Neither SCRAMRT_LOCALRT nor LOCALRT is defined" << std::endl; - return -1; - } - - try { - if (!edm::untaintString(argv[2], goodDirectory)) { - std::cerr << "Invalid test directory '" << argv[2] << "'" << std::endl; - return -1; - } - } catch (std::runtime_error const& e) { - std::cerr << "Invalid test directory '" << argv[2] << "'" << std::endl; - std::cerr << "e.what" << std::endl; - return -1; - } - - std::string testdir(topdir); - testdir += "/src/"; - testdir += argv[2]; - std::string tmpdir(topdir); - tmpdir += "/tmp/"; - tmpdir += arch; - std::string testbin(topdir); - testbin += "/test/"; - testbin += arch; - - std::cout << "topdir is: " << topdir << '\n'; - std::cout << "testdir is: " << testdir << '\n'; - std::cout << "tmpdir is: " << tmpdir << '\n'; - std::cout << "testbin is: " << testbin << '\n'; - - if (setenv("LOCAL_TEST_DIR", testdir.c_str(), 1) != 0) { - std::cerr << "Could not set LOCAL_TEST_DIR to " << testdir << std::endl; - return -1; - } - if (setenv("LOCAL_TMP_DIR", tmpdir.c_str(), 1) != 0) { - std::cerr << "Could not set LOCAL_TMP_DIR to " << tmpdir << std::endl; - return -1; - } - if (setenv("LOCAL_TOP_DIR", topdir, 1) != 0) { - std::cerr << "Could not set LOCAL_TOP_DIR to " << topdir << std::endl; - return -1; - } - if (setenv("LOCAL_TEST_BIN", testbin.c_str(), 1) != 0) { - std::cerr << "Could not set LOCAL_TEST_BIN to " << testbin << std::endl; - return -1; - } - - testdir += "/"; - - for (int i = 3; i < argc && rc == 0; ++i) { - std::string scriptname(testdir); - scriptname += argv[i]; - std::cout << "Running script: " << scriptname << std::endl; - rc = run_script(shell, scriptname); - } - - std::cout << "status = " << rc << std::endl; - return rc == 0 ? 0 : -1; -} - -int ptomaine(int argc, char* argv[], char** env) { - int rc = 1; - // Standalone executable, prints exception message - CMS_SA_ALLOW try { rc = do_work(argc, argv, env); } catch (edm::Exception& x) { - std::cerr << "Caught an edm::Exception in " << argv[0] << '\n' << x; - } catch (cms::Exception& x) { - std::cerr << "Caught a cms::Exception in " << argv[0] << '\n' << x; - } catch (std::exception& x) { - std::cerr << "Caught a std::exception in " << argv[0] << '\n' << x.what(); - } catch (...) { - std::cerr << "Caught an unknown exception in " << argv[0]; - } - return rc; -} diff --git a/FWCore/Utilities/test/README b/FWCore/Utilities/test/README deleted file mode 100644 index a79a1886a0340..0000000000000 --- a/FWCore/Utilities/test/README +++ /dev/null @@ -1,48 +0,0 @@ -How to make 'scram b runtests' run your shell script... - -Please note this is a hack, necessary only until 'scram b runtests' -can directly run a shell script. - -Here are the necessary items: - - 1. Write a source (.cpp) file that invokes the RUNTEST macro. Note - this is a C++ macro, not a CINT macro. The contents of your file - should be the following: - ------------------------------------------------------------- -#include "FWCore/Utilities/interface/TestHelper.h" -RUNTEST() ------------------------------------------------------------- - - 2. Add a binary target to your BuildFile that will build and run this - program, passing it the appropriate arguments. If your program name - is TestHelper (it should not be; you should name it - 'SubsystemPackagesMeaningfulName_t') - - - - - -The list of arguments in this target is - ' ...' -where - - a) shell name = the path to the shell you want (use bash!) - - b) current directory name = the name of the current directory (the - system isn't smart enough to figure this out) - - c) script1 ... is a sequence (of any length, subject to shell line - line restrictions) of the names of shell scripts to run. - - 3. Generally, you will have these shell scripts run binaries. These - shell scripts will have supplied to them several environment - variables: - - a) LOCAL_TEST_DIR: The directory where the test source code is. - b) LOCAL_TMP_DIR: The directory in which to create temporary files. - c) LOCAL_TOP_DIR: The directory that is the top of your local git - sandbox. - d) LOCAL_TEST_BIN: The directory in which your test binary is - found. - diff --git a/Geometry/GlobalTrackingGeometryBuilder/test/GlobalTrackingGeometryTest.cc b/Geometry/GlobalTrackingGeometryBuilder/test/GlobalTrackingGeometryTest.cc index 5e511c1dd74b0..e06a801a026b4 100644 --- a/Geometry/GlobalTrackingGeometryBuilder/test/GlobalTrackingGeometryTest.cc +++ b/Geometry/GlobalTrackingGeometryBuilder/test/GlobalTrackingGeometryTest.cc @@ -10,6 +10,7 @@ #include "FWCore/Framework/interface/EventSetup.h" #include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" #include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h" #include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h" @@ -30,7 +31,7 @@ class GlobalTrackingGeometryTest : public edm::one::EDAnalyzer<> { public: explicit GlobalTrackingGeometryTest(const edm::ParameterSet&); - ~GlobalTrackingGeometryTest() override; + ~GlobalTrackingGeometryTest() override = default; void beginJob() override {} void analyze(edm::Event const& iEvent, edm::EventSetup const&) override; @@ -52,8 +53,6 @@ GlobalTrackingGeometryTest::GlobalTrackingGeometryTest(const edm::ParameterSet& : my_name("GlobalTrackingGeometryTest"), geometryToken_{esConsumes(edm::ESInputTag{})} {} -GlobalTrackingGeometryTest::~GlobalTrackingGeometryTest() {} - void GlobalTrackingGeometryTest::analyzeCSC(const GlobalTrackingGeometry* geo, const CSCGeometry* cscGeometry) { for (auto& detUnit : cscGeometry->detUnits()) { const DetId detId(detUnit->geographicalId()); @@ -62,7 +61,7 @@ void GlobalTrackingGeometryTest::analyzeCSC(const GlobalTrackingGeometry* geo, c const GeomDetUnit* gdu(geo->idToDetUnit(detId)); assert(gdu == detUnit); } - std::cout << "CSC detUnit: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "CSC detUnit: GlobalTrackingGeometry succesfully tested."; for (auto& det : cscGeometry->dets()) { const DetId detId(det->geographicalId()); @@ -71,7 +70,7 @@ void GlobalTrackingGeometryTest::analyzeCSC(const GlobalTrackingGeometry* geo, c const GeomDet* gd(geo->idToDet(detId)); assert(gd == det); } - std::cout << "CSC det: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "CSC det: GlobalTrackingGeometry succesfully tested."; } void GlobalTrackingGeometryTest::analyzeDT(const GlobalTrackingGeometry* geo, const DTGeometry* dtGeometry) { @@ -82,7 +81,7 @@ void GlobalTrackingGeometryTest::analyzeDT(const GlobalTrackingGeometry* geo, co const GeomDetUnit* gdu(geo->idToDetUnit(detId)); assert(gdu == detUnit); } - std::cout << "DT detUnit: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "DT detUnit: GlobalTrackingGeometry succesfully tested."; for (auto& det : dtGeometry->dets()) { const DetId detId(det->geographicalId()); @@ -91,7 +90,7 @@ void GlobalTrackingGeometryTest::analyzeDT(const GlobalTrackingGeometry* geo, co const GeomDet* gd(geo->idToDet(detId)); assert(gd == det); } - std::cout << "DT det: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "DT det: GlobalTrackingGeometry succesfully tested."; } void GlobalTrackingGeometryTest::analyzeRPC(const GlobalTrackingGeometry* geo, const RPCGeometry* rpcGeometry) { @@ -102,7 +101,7 @@ void GlobalTrackingGeometryTest::analyzeRPC(const GlobalTrackingGeometry* geo, c const GeomDetUnit* gdu(geo->idToDetUnit(detId)); assert(gdu == detUnit); } - std::cout << "RPC detUnit: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "RPC detUnit: GlobalTrackingGeometry succesfully tested."; for (auto& det : rpcGeometry->dets()) { const DetId detId(det->geographicalId()); @@ -111,7 +110,7 @@ void GlobalTrackingGeometryTest::analyzeRPC(const GlobalTrackingGeometry* geo, c const GeomDet* gd(geo->idToDet(detId)); assert(gd == det); } - std::cout << "RPC det: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "RPC det: GlobalTrackingGeometry succesfully tested."; } void GlobalTrackingGeometryTest::analyzeGEM(const GlobalTrackingGeometry* geo, const GEMGeometry* gemGeometry) { @@ -122,7 +121,7 @@ void GlobalTrackingGeometryTest::analyzeGEM(const GlobalTrackingGeometry* geo, c const GeomDetUnit* gdu(geo->idToDetUnit(detId)); assert(gdu == detUnit); } - std::cout << "GEM detUnit: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "GEM detUnit: GlobalTrackingGeometry succesfully tested."; for (auto& det : gemGeometry->dets()) { const DetId detId(det->geographicalId()); @@ -131,7 +130,7 @@ void GlobalTrackingGeometryTest::analyzeGEM(const GlobalTrackingGeometry* geo, c const GeomDet* gd(geo->idToDet(detId)); assert(gd == det); } - std::cout << "GEM det: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "GEM det: GlobalTrackingGeometry succesfully tested."; } void GlobalTrackingGeometryTest::analyzeMTD(const GlobalTrackingGeometry* geo, const MTDGeometry* mtdGeometry) { @@ -142,7 +141,7 @@ void GlobalTrackingGeometryTest::analyzeMTD(const GlobalTrackingGeometry* geo, c const GeomDetUnit* gdu(geo->idToDetUnit(detId)); assert(gdu == detUnit); } - std::cout << "MTD detUnit: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "MTD detUnit: GlobalTrackingGeometry succesfully tested."; for (auto& det : mtdGeometry->dets()) { const DetId detId(det->geographicalId()); @@ -151,7 +150,7 @@ void GlobalTrackingGeometryTest::analyzeMTD(const GlobalTrackingGeometry* geo, c const GeomDet* gd(geo->idToDet(detId)); assert(gd == det); } - std::cout << "MTD det: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "MTD det: GlobalTrackingGeometry succesfully tested."; } void GlobalTrackingGeometryTest::analyzeTracker(const GlobalTrackingGeometry* geo, const TrackerGeometry* tkGeometry) { @@ -162,7 +161,7 @@ void GlobalTrackingGeometryTest::analyzeTracker(const GlobalTrackingGeometry* ge const GeomDetUnit* gdu(geo->idToDetUnit(detId)); assert(gdu == detUnit); } - std::cout << "Tracker detUnit: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "Tracker detUnit: GlobalTrackingGeometry succesfully tested."; for (auto& det : tkGeometry->dets()) { const DetId detId(det->geographicalId()); @@ -171,72 +170,66 @@ void GlobalTrackingGeometryTest::analyzeTracker(const GlobalTrackingGeometry* ge const GeomDet* gd(geo->idToDet(detId)); assert(gd == det); } - std::cout << "Tracker det: GlobalTrackingGeometry succesfully tested." << std::endl; + edm::LogVerbatim("GlobalTracking") << "Tracker det: GlobalTrackingGeometry succesfully tested."; } void GlobalTrackingGeometryTest::analyze(const edm::Event& /*iEvent*/, const edm::EventSetup& iSetup) { - std::cout << myName() << ": Analyzer..." << std::endl; + edm::LogVerbatim("GlobalTracking") << myName() << ": Analyzer..."; const auto& geo = iSetup.getData(geometryToken_); DetId detId1(DetId::Tracker, 0); const TrackerGeometry* trackerGeometry = nullptr; - std::cout << "Pointer to Tracker Geometry: "; try { trackerGeometry = (const TrackerGeometry*)geo.slaveGeometry(detId1); - std::cout << trackerGeometry << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to Tracker Geometry: " << trackerGeometry; } catch (...) { - std::cout << "N/A" << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to Tracker Geometry: N/A"; } DetId detId6(DetId::Forward, 1); const MTDGeometry* mtdGeometry = nullptr; - std::cout << "Pointer to MTD Geometry: "; try { mtdGeometry = (const MTDGeometry*)geo.slaveGeometry(detId6); - std::cout << mtdGeometry << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to MTD Geometry: " << mtdGeometry; } catch (...) { - std::cout << "N/A" << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to MTD Geometry: N/A"; } DetId detId2(DetId::Muon, 1); const DTGeometry* dtGeometry = nullptr; - std::cout << "Pointer to DT Geometry: "; try { dtGeometry = (const DTGeometry*)geo.slaveGeometry(detId2); - std::cout << dtGeometry << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to DT Geometry: " << dtGeometry; } catch (...) { - std::cout << "N/A" << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to DT Geometry: N/A"; } DetId detId3(DetId::Muon, 2); const CSCGeometry* cscGeometry = nullptr; - std::cout << "Pointer to CSC Geometry: "; try { cscGeometry = (const CSCGeometry*)geo.slaveGeometry(detId3); - std::cout << cscGeometry << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to CSC Geometry: " << cscGeometry; } catch (...) { - std::cout << "N/A" << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to CSC Geometry: N/A"; } DetId detId4(DetId::Muon, 3); const RPCGeometry* rpcGeometry = nullptr; - std::cout << "Pointer to RPC Geometry: "; try { rpcGeometry = (const RPCGeometry*)geo.slaveGeometry(detId4); - std::cout << rpcGeometry << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to RPC Geometry: " << rpcGeometry; } catch (...) { - std::cout << "N/A" << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to RPC Geometry: N/A"; } DetId detId5(DetId::Muon, 4); const GEMGeometry* gemGeometry = nullptr; - std::cout << "Pointer to GEM Geometry: "; try { gemGeometry = (const GEMGeometry*)geo.slaveGeometry(detId5); - std::cout << gemGeometry << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to GEM Geometry: " << gemGeometry; } catch (...) { - std::cout << "N/A" << std::endl; + edm::LogVerbatim("GlobalTracking") << "Pointer to GEM Geometry: N/A"; } if (cscGeometry) diff --git a/Geometry/GlobalTrackingGeometryBuilder/test/testGlobalTrackingGeometry_cfg.py b/Geometry/GlobalTrackingGeometryBuilder/test/testGlobalTrackingGeometry_cfg.py index 386b122f652da..d084295f27403 100644 --- a/Geometry/GlobalTrackingGeometryBuilder/test/testGlobalTrackingGeometry_cfg.py +++ b/Geometry/GlobalTrackingGeometryBuilder/test/testGlobalTrackingGeometry_cfg.py @@ -1,22 +1,22 @@ import FWCore.ParameterSet.Config as cms +from Configuration.Eras.Era_Phase2C17I13M9_cff import Phase2C17I13M9 -process = cms.Process("Demo") -process.load('Configuration.Geometry.GeometryExtended2023D24_cff') -process.load('Configuration.Geometry.GeometryExtended2023D24Reco_cff') -process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process = cms.Process("Demo",Phase2C17I13M9) +process.load('Configuration.Geometry.GeometryExtended2026D99Reco_cff') process.load('FWCore.MessageLogger.MessageLogger_cfi') +if 'MessageLogger' in process.__dict__: + process.MessageLogger.GlobalTracking=dict() +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic', '') +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic_T25', '') process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1) ) process.source = cms.Source("EmptySource") -process.MessageLogger = cms.Service("MessageLogger") - process.test = cms.EDAnalyzer("GlobalTrackingGeometryTest") process.p = cms.Path(process.test) diff --git a/Geometry/HcalEventSetup/python/HcalDDDGeometry_cfi.py b/Geometry/HcalEventSetup/python/HcalDDDGeometry_cfi.py new file mode 100644 index 0000000000000..6dcd4d747ed8e --- /dev/null +++ b/Geometry/HcalEventSetup/python/HcalDDDGeometry_cfi.py @@ -0,0 +1,8 @@ +import FWCore.ParameterSet.Config as cms + +# Ideal geometry, needed for simulation +from Geometry.CMSCommonData.hcalOnlyGeometryXML_cfi import * +from Geometry.HcalCommonData.hcalDDDSimConstants_cff import * + + + diff --git a/Geometry/HcalEventSetup/src/HcalTopologyIdealEP.cc b/Geometry/HcalEventSetup/src/HcalTopologyIdealEP.cc index 26442555f107a..5fe4404748e03 100644 --- a/Geometry/HcalEventSetup/src/HcalTopologyIdealEP.cc +++ b/Geometry/HcalEventSetup/src/HcalTopologyIdealEP.cc @@ -24,15 +24,15 @@ #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSetDescription.h" -//#define DebugLog +//#define EDM_ML_DEBUG HcalTopologyIdealEP::HcalTopologyIdealEP(const edm::ParameterSet& conf) : m_hdcToken{setWhatProduced(this, &HcalTopologyIdealEP::produce).consumes(edm::ESInputTag{})}, m_restrictions(conf.getUntrackedParameter("Exclude")), m_mergePosition(conf.getUntrackedParameter("MergePosition")) { -#ifdef DebugLog - std::cout << "HcalTopologyIdealEP::HcalTopologyIdealEP with Exclude: " << m_restrictions - << " MergePosition: " << m_mergePosition << std::endl; +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HCalGeom") << "HcalTopologyIdealEP::HcalTopologyIdealEP with Exclude: " << m_restrictions + << " MergePosition: " << m_mergePosition; edm::LogInfo("HCAL") << "HcalTopologyIdealEP::HcalTopologyIdealEP"; #endif } @@ -46,15 +46,15 @@ void HcalTopologyIdealEP::fillDescriptions(edm::ConfigurationDescriptions& descr // ------------ method called to produce the data ------------ HcalTopologyIdealEP::ReturnType HcalTopologyIdealEP::produce(const HcalRecNumberingRecord& iRecord) { -#ifdef DebugLog - std::cout << "HcalTopologyIdealEP::produce(const IdealGeometryRecord& iRecord)" << std::endl; +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HCalGeom") << "HcalTopologyIdealEP::produce(const IdealGeometryRecord& iRecord)"; edm::LogInfo("HCAL") << "HcalTopologyIdealEP::produce(const HcalGeometryRecord& iRecord)"; #endif const HcalDDDRecConstants& hdc = iRecord.get(m_hdcToken); -#ifdef DebugLog - std::cout << "mode = " << hdc.getTopoMode() << ", maxDepthHB = " << hdc.getMaxDepth(0) - << ", maxDepthHE = " << hdc.getMaxDepth(1) << ", maxDepthHF = " << hdc.getMaxDepth(2) << std::endl; +#ifdef EDM_ML_DEBUG + edm::LogVerbatim("HCalGeom") << "mode = " << hdc.getTopoMode() << ", maxDepthHB = " << hdc.getMaxDepth(0) + << ", maxDepthHE = " << hdc.getMaxDepth(1) << ", maxDepthHF = " << hdc.getMaxDepth(2); edm::LogInfo("HCAL") << "mode = " << hdc.getTopoMode() << ", maxDepthHB = " << hdc.getMaxDepth(0) << ", maxDepthHE = " << hdc.getMaxDepth(1) << ", maxDepthHF = " << hdc.getMaxDepth(2); #endif diff --git a/Geometry/HcalEventSetup/test/runTestHcalDDDGeometry_cfg.py b/Geometry/HcalEventSetup/test/runTestHcalDDDGeometry_cfg.py index bb52fb06eb302..97ce345b186e0 100644 --- a/Geometry/HcalEventSetup/test/runTestHcalDDDGeometry_cfg.py +++ b/Geometry/HcalEventSetup/test/runTestHcalDDDGeometry_cfg.py @@ -7,23 +7,9 @@ #process.load("Configuration.StandardSequences.MagneticField_cff") -process.MessageLogger = cms.Service("MessageLogger", - destinations = cms.untracked.vstring('cout'), - categories = cms.untracked.vstring('HCalGeom'), - debugModules = cms.untracked.vstring('*'), - cout = cms.untracked.PSet( - threshold = cms.untracked.string('DEBUG'), - INFO = cms.untracked.PSet( - limit = cms.untracked.int32(-1) - ), - DEBUG = cms.untracked.PSet( - limit = cms.untracked.int32(0) - ), - HCalGeom = cms.untracked.PSet( - limit = cms.untracked.int32(-1) - ) - ) -) +process.load('FWCore.MessageService.MessageLogger_cfi') +if 'MessageLogger' in process.__dict__: + process.MessageLogger.HCalGeom=dict() process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(10) diff --git a/Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2006-algorithm.xml b/Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2006-algorithm.xml new file mode 100644 index 0000000000000..453f2b6bbd3e6 --- /dev/null +++ b/Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2006-algorithm.xml @@ -0,0 +1,47 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2007-algorithm.xml b/Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2007-algorithm.xml new file mode 100644 index 0000000000000..6fb0079b44436 --- /dev/null +++ b/Geometry/HcalTestBeamData/data/dd4hep/cms-test-ddTB2007-algorithm.xml @@ -0,0 +1,50 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/HcalTestBeamData/plugins/HcalTBParameterTester.cc b/Geometry/HcalTestBeamData/plugins/HcalTBParameterTester.cc index 929f0c3813877..6cd19304d2686 100644 --- a/Geometry/HcalTestBeamData/plugins/HcalTBParameterTester.cc +++ b/Geometry/HcalTestBeamData/plugins/HcalTBParameterTester.cc @@ -5,6 +5,7 @@ #include "FWCore/Framework/interface/EventSetup.h" #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/Framework/interface/one/EDAnalyzer.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" #include "Geometry/HcalTestBeamData/interface/HcalTB02Parameters.h" #include "Geometry/HcalTestBeamData/interface/HcalTB06BeamParameters.h" @@ -13,7 +14,7 @@ class HcalTBParameterTester : public edm::one::EDAnalyzer<> { public: explicit HcalTBParameterTester(const edm::ParameterSet&); - ~HcalTBParameterTester() override {} + ~HcalTBParameterTester() override = default; void beginJob() override {} void analyze(edm::Event const& iEvent, edm::EventSetup const&) override; @@ -36,19 +37,19 @@ void HcalTBParameterTester::analyze(const edm::Event& iEvent, const edm::EventSe if (mode_ == 0) { const auto& hcp = iSetup.getData(token1_); const auto* php = &hcp; - std::cout << "TB02Parameters for " << name_ << "\n"; - std::cout << "Length map with " << php->lengthMap_.size() << " elements\n"; + edm::LogVerbatim("HCalGeom") << "TB02Parameters for " << name_; + edm::LogVerbatim("HCalGeom") << "Length map with " << php->lengthMap_.size() << " elements"; std::map::const_iterator itr = php->lengthMap_.begin(); int i(0); for (; itr != php->lengthMap_.end(); ++itr, ++i) - std::cout << "[" << i << "] " << itr->first << " " << itr->second << " mm\n"; + edm::LogVerbatim("HCalGeom") << "[" << i << "] " << itr->first << " " << itr->second << " mm"; } else { const auto& hcp = iSetup.getData(token2_); const auto* php = &hcp; - std::cout << "TB06BeamParameters:: Material " << php->material_ << "\n"; - std::cout << "TB06BeamParameters:: " << php->wchambers_.size() << " wire chambers:\n"; + edm::LogVerbatim("HCalGeom") << "TB06BeamParameters:: Material " << php->material_; + edm::LogVerbatim("HCalGeom") << "TB06BeamParameters:: " << php->wchambers_.size() << " wire chambers:"; for (unsigned int k = 0; k < php->wchambers_.size(); ++k) - std::cout << "[" << k << "] " << php->wchambers_[k] << "\n"; + edm::LogVerbatim("HCalGeom") << "[" << k << "] " << php->wchambers_[k]; } } diff --git a/HeterogeneousCore/SonicTriton/test/BuildFile.xml b/HeterogeneousCore/SonicTriton/test/BuildFile.xml index 2943bc9931d02..272fba3da2cc8 100644 --- a/HeterogeneousCore/SonicTriton/test/BuildFile.xml +++ b/HeterogeneousCore/SonicTriton/test/BuildFile.xml @@ -1,6 +1,3 @@ - - - diff --git a/L1Trigger/Phase2L1GMT/plugins/Phase2L1TGMTSAMuonProducer.cc b/L1Trigger/Phase2L1GMT/plugins/Phase2L1TGMTSAMuonProducer.cc index 5f64b43b10ccc..c6284873729c5 100644 --- a/L1Trigger/Phase2L1GMT/plugins/Phase2L1TGMTSAMuonProducer.cc +++ b/L1Trigger/Phase2L1GMT/plugins/Phase2L1TGMTSAMuonProducer.cc @@ -127,17 +127,17 @@ void Phase2L1TGMTSAMuonProducer::produce(edm::Event& iEvent, const edm::EventSet // Description: // =========================================================================== SAMuon Phase2L1TGMTSAMuonProducer::Convertl1tMuon(const l1t::Muon& mu, const int bx_) { - ap_uint qual = mu.hwQual(); + qual_sa_t qual = mu.hwQual(); int charge = mu.charge() > 0 ? 0 : 1; - ap_uint pt = round(mu.pt() / LSBpt); - ap_int phi = round(mu.phi() / LSBphi); - ap_int eta = round(mu.eta() / LSBeta); + pt_sa_t pt = round(mu.pt() / LSBpt); + phi_sa_t phi = round(mu.phi() / LSBphi); + eta_sa_t eta = round(mu.eta() / LSBeta); // FIXME: Below are not well defined in phase1 GMT // Using the version from Correlator for now - ap_int z0 = 0; // No tracks info in Phase 1 + z0_sa_t z0 = 0; // No tracks info in Phase 1 // Use 2 bits with LSB = 30cm for BMTF and 25cm for EMTF currently, but subjet to change - ap_int d0 = mu.hwDXY(); + d0_sa_t d0 = mu.hwDXY(); int bstart = 0; wordtype word(0); @@ -148,7 +148,7 @@ SAMuon Phase2L1TGMTSAMuonProducer::Convertl1tMuon(const l1t::Muon& mu, const int bstart = wordconcat(word, bstart, z0, BITSSAZ0); bstart = wordconcat(word, bstart, d0, BITSSAD0); bstart = wordconcat(word, bstart, charge, 1); - bstart = wordconcat(word, bstart, qual, BITSSAQUALITY); + bstart = wordconcat(word, bstart, qual, BITSSAQUAL); SAMuon samuon(mu, charge, pt.to_uint(), eta.to_int(), phi.to_int(), z0.to_int(), d0.to_int(), qual.to_uint()); samuon.setWord(word); diff --git a/L1Trigger/Phase2L1GMT/plugins/TrackMuonMatchAlgorithm.h b/L1Trigger/Phase2L1GMT/plugins/TrackMuonMatchAlgorithm.h index 3df98ee6ed63e..30f3ad6d8a3f5 100644 --- a/L1Trigger/Phase2L1GMT/plugins/TrackMuonMatchAlgorithm.h +++ b/L1Trigger/Phase2L1GMT/plugins/TrackMuonMatchAlgorithm.h @@ -105,7 +105,7 @@ namespace Phase2L1GMT { if (out.size() == maximum) break; l1t::TrackerMuon muon(mu.trkPtr(), mu.charge(), mu.pt(), mu.eta(), mu.phi(), mu.z0(), mu.d0(), mu.quality()); - //muon.setMuonRef(mu.muonRef()); + muon.setMuonRef(mu.muonRef()); for (const auto& stub : mu.stubs()) muon.addStub(stub); out.push_back(muon); @@ -131,9 +131,9 @@ namespace Phase2L1GMT { bstart = 0; bstart = wordconcat(word2, bstart, mu.hwCharge(), 1); - bstart = wordconcat(word2, bstart, mu.hwQual(), BITSGTQUALITY); + bstart = wordconcat(word2, bstart, mu.hwQual(), BITSGTQUAL); bstart = wordconcat(word2, bstart, mu.hwIso(), BITSGTISO); - bstart = wordconcat(word2, bstart, mu.hwBeta(), BITSMUONBETA); + bstart = wordconcat(word2, bstart, mu.hwBeta(), BITSGTBETA); std::array wordout = {{word1, word2}}; mu.setWord(wordout); diff --git a/L1Trigger/Phase2L1GMT/python/gmt_cfi.py b/L1Trigger/Phase2L1GMT/python/gmt_cfi.py index 6e8bcde812de1..e5d24cf7bd955 100644 --- a/L1Trigger/Phase2L1GMT/python/gmt_cfi.py +++ b/L1Trigger/Phase2L1GMT/python/gmt_cfi.py @@ -70,7 +70,7 @@ RelIsoThresholdM = cms.double(0.05), RelIsoThresholdT = cms.double(0.01), verbose = cms.int32(0), - IsodumpForHLS = cms.int32(1), + IsodumpForHLS = cms.int32(0), ), tauto3mu = cms.PSet() diff --git a/L1Trigger/Phase2L1GMT/test/runGMT.py b/L1Trigger/Phase2L1GMT/test/runGMT.py index 4a870ad535b43..26c0aec35ae64 100644 --- a/L1Trigger/Phase2L1GMT/test/runGMT.py +++ b/L1Trigger/Phase2L1GMT/test/runGMT.py @@ -115,30 +115,10 @@ process.dtTriggerPhase2PrimitiveDigis.scenario = 0 process.load("L1Trigger.Phase2L1GMT.gmt_cff") -process.l1tGMTMuons.trackMatching.verbose=1 -process.l1tGMTMuons.verbose=0 -process.l1tGMTMuons.trackConverter.verbose=0 - - - -#process.schedule = cms.Schedule(process.L1TrackTrigger_step,process.pL1TMuonTPS,process.endjob_step,process.e) # Adding MuonTPS - # Path and EndPath definitions process.raw2digi_step = cms.Path(process.RawToDigi) process.L1TrackTrigger_step = cms.Path(process.L1TrackTrigger) -#process.pL1TkPhotonsCrystal = cms.Path(process.L1TkPhotonsCrystal) -#process.pL1TkIsoElectronsCrystal = cms.Path(process.L1TkIsoElectronsCrystal) -#process.pL1TkElectronsLooseCrystal = cms.Path(process.L1TkElectronsLooseCrystal) -#process.pL1TkElectronsLooseHGC = cms.Path(process.L1TkElectronsLooseHGC) -#process.pL1TkElectronsHGC = cms.Path(process.L1TkElectronsHGC) -process.pL1TkMuon = cms.Path(process.L1TkMuons+process.L1TkMuonsTP) -#process.pL1TkElectronsEllipticMatchHGC = cms.Path(process.L1TkElectronsEllipticMatchHGC) -#process.pL1TkElectronsCrystal = cms.Path(process.L1TkElectronsCrystal) -#process.pL1TkPhotonsHGC = cms.Path(process.L1TkPhotonsHGC) -#process.pL1TkIsoElectronsHGC = cms.Path(process.L1TkIsoElectronsHGC) -#process.pL1TkElectronsEllipticMatchCrystal = cms.Path(process.L1TkElectronsEllipticMatchCrystal) -#process.L1simulation_step = cms.Path(process.SimL1Emulator) process.testpath=cms.Path(process.CalibratedDigis*process.dtTriggerPhase2PrimitiveDigis*process.phase2GMT) process.endjob_step = cms.EndPath(process.endOfProcess) process.FEVTDEBUGHLToutput_step = cms.EndPath(process.FEVTDEBUGHLToutput) diff --git a/RecoEcal/EgammaClusterProducers/test/BuildFile.xml b/RecoEcal/EgammaClusterProducers/test/BuildFile.xml index b83b4d100f648..330f479305f47 100644 --- a/RecoEcal/EgammaClusterProducers/test/BuildFile.xml +++ b/RecoEcal/EgammaClusterProducers/test/BuildFile.xml @@ -9,8 +9,4 @@ - - - - - + From 8a8eeaf96906fbf8808afabdd6b3ea7659436125 Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Fri, 7 Apr 2023 09:29:00 +0200 Subject: [PATCH 12/17] ParT from mini --- .../NanoAOD/python/jetsAK4_CHS_cff.py | 8 +++--- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 9 ++++-- PhysicsTools/NanoAOD/python/nano_cff.py | 6 ++-- .../PatAlgos/python/tools/jetTools.py | 28 ++++++++++++------- .../python/pfParticleTransformerAK4_cff.py | 4 +++ 5 files changed, 37 insertions(+), 18 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index b6d9d51a276a5..6359346928b5a 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -379,16 +379,16 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet, if addDeepFlavour: print("Updating process to run DeepFlavour btag") _btagDiscriminators += ['pfDeepFlavourJetTags:probb','pfDeepFlavourJetTags:probbb','pfDeepFlavourJetTags:problepb','pfDeepFlavourJetTags:probc'] - - if addRobustParTAK4: - print("Updating process to run RobustParTAK4 btag") - _btagDiscriminators += ['pfParticleTransformerAK4JetTags:probb','pfParticleTransformerAK4JetTags:probbb','pfParticleTransformerAK4JetTags:problepb','pfParticleTransformerAK4JetTags:probc'] if addParticleNet: print("Updating process to run ParticleNetAK4") from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll 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)) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 8dc50bcccbf67..05a8a80f05ac9 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -141,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): _btagDiscriminators=[] if addParticleNet: print("Updating process to run ParticleNetAK4") @@ -149,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( @@ -164,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/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index 6df7b6357a03e..12d1b1c6cab3f 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -157,12 +157,14 @@ 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 diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index e533031263f96..a8256e7144f63 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -671,20 +671,28 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = True else: flip = False - if not ('limmed' in jetSource.value()): + # 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") - else: - puppi_value_map = cms.InputTag("") - vertex_associator = cms.InputTag("") + + # 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, - flip = flip), + 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': diff --git a/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py index 4c6caa07923d2..0fb1c8ceac050 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleTransformerAK4_cff.py @@ -23,3 +23,7 @@ pfParticleTransformerAK4Task = cms.Task(puppi, primaryVertexAssociation, pfParticleTransformerAK4TagInfos, pfParticleTransformerAK4JetTags, pfParticleTransformerAK4DiscriminatorsJetTags) +# run from MiniAOD instead +pfParticleTransformerAK4FromMiniAODTask = cms.Task(pfParticleTransformerAK4TagInfos, + pfParticleTransformerAK4JetTags, + pfParticleTransformerAK4DiscriminatorsJetTags) From b0c08382ab6dfdece2846da7d41a441aa9de179d Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Mon, 10 Apr 2023 18:51:24 +0200 Subject: [PATCH 13/17] replace nominal with robust+fast ParT model --- .../plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc index c2dc8e6b75319..b7e85314b087f 100644 --- a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -85,7 +85,7 @@ void ParticleTransformerAK4ONNXJetTagsProducer::fillDescriptions(edm::Configurat 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/ParTAK4.onnx")); + 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"}); From a8947fa60d61a6337ef457af57018b37faaf3278 Mon Sep 17 00:00:00 2001 From: Alexandre De Moor <70885737+AlexDeMoor@users.noreply.github.com> Date: Fri, 14 Apr 2023 11:00:24 +0200 Subject: [PATCH 14/17] Add the jet selection for ParT AK4 (#6) * Modifications to JetTags for jet selections Modify the JetTags producer for skipping the non selected jets and processing the good ones only * Update ParT TagInfo for jet selection * Add the bool for jet selection --- .../ParticleTransformerAK4Features.h | 1 + .../ParticleTransformerAK4TagInfoProducer.cc | 364 +++++++++--------- ...rticleTransformerAK4ONNXJetTagsProducer.cc | 112 +++--- 3 files changed, 236 insertions(+), 241 deletions(-) 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/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index 7336273ec7ce7..b040f74c03ab7 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -197,219 +197,229 @@ void ParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const ed // reco jet reference (use as much as possible) const auto& jet = jets->at(jet_n); if (jet.pt() < 15.0) { - continue; + 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); - 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_); + 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 + // 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()); + } + } + } - std::vector> c_sorted, n_sorted; + // 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); - // to cache the TrackInfo - std::map trackinfos; + std::vector c_sortedindices, n_sortedindices; - // 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); + // this puts 0 everywhere and the right position in ind + c_sortedindices = btagbtvdeep::invertSortingVector(c_sorted); + n_sortedindices = btagbtvdeep::invertSortingVector(n_sorted); - 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()); - } - } - } + // 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()); - // 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); - } + 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; - reco::CandidatePtr cand_ptr; - if (pat_jet) { - cand_ptr = pat_jet->sourceCandidatePtr(i); - } + auto packed_cand = dynamic_cast(cand); + auto reco_cand = dynamic_cast(cand); - // - // 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"; + // 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); } - } 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"; + + reco::CandidatePtr cand_ptr; + if (pat_jet) { + cand_ptr = pat_jet->sourceCandidatePtr(i); } - } 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); + // + // 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, + 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 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()); + } 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); } - 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)); } diff --git a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc index b7e85314b087f..4c61007b6f689 100644 --- a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -12,6 +12,7 @@ #include "DataFormats/BTauReco/interface/JetTag.h" #include "DataFormats/BTauReco/interface/ParticleTransformerAK4TagInfo.h" +#include "DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h" #include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" @@ -33,8 +34,8 @@ class ParticleTransformerAK4ONNXJetTagsProducer : public edm::stream::EDProducer void produce(edm::Event&, const edm::EventSetup&) override; - void make_inputs(unsigned i_jet, const reco::ParticleTransformerAK4TagInfo& taginfo); - void get_input_sizes(edm::Handle tag_infos); + void make_inputs(btagbtvdeep::ParticleTransformerAK4Features features); + void get_input_sizes(const reco::FeaturesTagInfo taginfo); const edm::EDGetTokenT src_; std::vector flav_names_; @@ -104,77 +105,62 @@ void ParticleTransformerAK4ONNXJetTagsProducer::produce(edm::Event& iEvent, cons edm::Handle tag_infos; iEvent.getByToken(src_, tag_infos); + // initialize output collection std::vector> output_tags; if (!tag_infos->empty()) { - // initialize output collection 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)); } - get_input_sizes(tag_infos); - - // init data storage - data_.clear(); - for (const auto& len : input_sizes_) { - data_.emplace_back(tag_infos->size() * len, 0); - } - // convert inputs - for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& taginfo = (*tag_infos)[jet_n]; - make_inputs(jet_n, taginfo); - } - // run prediction with dynamic batch size per event - input_shapes_ = {{(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_features_cpf_}, - {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_features_npf_}, - {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_features_sv_}, - {(int64_t)tag_infos->size(), (int64_t)n_cpf_, (int64_t)n_pairwise_features_cpf_}, - {(int64_t)tag_infos->size(), (int64_t)n_npf_, (int64_t)n_pairwise_features_npf_}, - {(int64_t)tag_infos->size(), (int64_t)n_sv_, (int64_t)n_pairwise_features_sv_}}; - - auto outputs = globalCache()->run(input_names_, data_, input_shapes_, output_names_, tag_infos->size())[0]; - assert(outputs.size() == flav_names_.size() * tag_infos->size()); - - // get the outputs - unsigned i_output = 0; - for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - 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[i_output]; - ++i_output; - } - } } else { - // create empty output collection 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(edm::Handle tag_infos) { - for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { - const auto& taginfo = (*tag_infos)[jet_n]; - 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(); - - if (jet_n == 0) { - 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); - } else { - n_cpf_ = std::max(n_cpf_, n_cpf); - n_npf_ = std::max(n_npf_, n_npf); - n_sv_ = std::max(n_sv_, n_vtx); - } - } +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_); @@ -186,18 +172,22 @@ void ParticleTransformerAK4ONNXJetTagsProducer::get_input_sizes(edm::Handle Date: Tue, 18 Apr 2023 12:48:15 +0200 Subject: [PATCH 15/17] fix typo: add missing char for CHS,PUPPI nano --- PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py | 2 +- PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 6359346928b5a..2ae72f9debc33 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -135,7 +135,7 @@ 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"), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), - btagRobustParTAK4B = Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4etTags:problepb')", + btagRobustParTAK4B = Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')", float, doc="RobustParTAK4 b+bb+lepb tag discriminator", precision=10), diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 05a8a80f05ac9..261446473c82c 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -82,7 +82,7 @@ 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"), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), - btagRobustParTAK4B = Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4etTags:problepb')",float,doc="RobustParTAK4 b+bb+lepb tag 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), From c857a5435a576f1f54f785496c5f040a6777af7d Mon Sep 17 00:00:00 2001 From: Alexandre De Moor <70885737+AlexDeMoor@users.noreply.github.com> Date: Thu, 27 Apr 2023 18:04:57 +0200 Subject: [PATCH 16/17] Add modifications respecting comments (#7) --- .../ParticleTransformerAK4TagInfoProducer.cc | 20 +++++++++---------- ...rticleTransformerAK4ONNXJetTagsProducer.cc | 4 +--- 2 files changed, 10 insertions(+), 14 deletions(-) diff --git a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc index b040f74c03ab7..1d66657ccc822 100644 --- a/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc +++ b/RecoBTag/FeatureTools/plugins/ParticleTransformerAK4TagInfoProducer.cc @@ -60,7 +60,7 @@ class HistogramProbabilityEstimator; class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { public: explicit ParticleTransformerAK4TagInfoProducer(const edm::ParameterSet&); - ~ParticleTransformerAK4TagInfoProducer() override; + ~ParticleTransformerAK4TagInfoProducer() override = default; static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); @@ -77,21 +77,21 @@ class ParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { const double min_candidate_pt_; const bool flip_; - edm::EDGetTokenT> jet_token_; - edm::EDGetTokenT vtx_token_; - edm::EDGetTokenT sv_token_; + 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_; - edm::EDGetTokenT> candidateToken_; - edm::ESGetToken track_builder_token_; + const edm::EDGetTokenT> candidateToken_; + const edm::ESGetToken track_builder_token_; bool use_puppi_value_map_; bool use_pvasq_value_map_; - bool fallback_puppi_weight_; - bool fallback_vertex_association_; + const bool fallback_puppi_weight_; + const bool fallback_vertex_association_; - bool is_weighted_jet_; + const bool is_weighted_jet_; const double min_jet_pt_; const double max_jet_eta_; @@ -133,8 +133,6 @@ ParticleTransformerAK4TagInfoProducer::ParticleTransformerAK4TagInfoProducer(con } } -ParticleTransformerAK4TagInfoProducer::~ParticleTransformerAK4TagInfoProducer() {} - void ParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { // pfParticleTransformerAK4TagInfos edm::ParameterSetDescription desc; diff --git a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc index 4c61007b6f689..b27a9b397e520 100644 --- a/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc +++ b/RecoBTag/ONNXRuntime/plugins/ParticleTransformerAK4ONNXJetTagsProducer.cc @@ -21,7 +21,7 @@ using namespace cms::Ort; class ParticleTransformerAK4ONNXJetTagsProducer : public edm::stream::EDProducer> { public: explicit ParticleTransformerAK4ONNXJetTagsProducer(const edm::ParameterSet&, const ONNXRuntime*); - ~ParticleTransformerAK4ONNXJetTagsProducer() override; + ~ParticleTransformerAK4ONNXJetTagsProducer() override = default; static void fillDescriptions(edm::ConfigurationDescriptions&); @@ -78,8 +78,6 @@ ParticleTransformerAK4ONNXJetTagsProducer::ParticleTransformerAK4ONNXJetTagsProd } } -ParticleTransformerAK4ONNXJetTagsProducer::~ParticleTransformerAK4ONNXJetTagsProducer() {} - void ParticleTransformerAK4ONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { // pfParticleTransformerAK4JetTags edm::ParameterSetDescription desc; From 4e2ae70b05a67fc36b713e57adbe7ed0fd5a9e0a Mon Sep 17 00:00:00 2001 From: Annika Stein Date: Tue, 2 May 2023 11:02:08 +0200 Subject: [PATCH 17/17] fix kwargs for RobustParTAK4 to resolve conflict with tau pog addition --- PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py | 2 +- PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 2ae72f9debc33..3d45018f7d0bc 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -371,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,addRobustParTAK4): +def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet,addRobustParTAK4=False): _btagDiscriminators=[] if addDeepBTag: print("Updating process to run DeepCSV btag") diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 261446473c82c..91ff1a97deefe 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -141,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,addRobustParTAK4): +def nanoAOD_addDeepInfoAK4(process,addParticleNet,addRobustParTAK4=False): _btagDiscriminators=[] if addParticleNet: print("Updating process to run ParticleNetAK4")