cmsRun config to produce Scouting and HLT AK4PFJets nano from RAW in 15x/Winter25

cmsRun_cfg_150x_ScoutAndHLTPFJets_fromRAW.py

# Auto generated configuration file
# using: 
# Revision: 1.19 
# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v 
# with command line options: --python_filename cfg_nano_wScout.py --processName=HLTX --eventcontent NANOAODSIM --customise Configuration/DataProcessing/Utils.addMonitoring --datatier NANOAODSIM --fileout file:nano_out.root --conditions 142X_mcRun3_2025_realistic_v7 --step NANO:@Scout --nThreads 4 --filein file:TSG-Run3Winter25MiniAOD-00009.root --era Run3_2025 --no_exec --mc -n 10000
import FWCore.ParameterSet.Config as cms

from Configuration.Eras.Era_Run3_2025_cff import Run3_2025

process = cms.Process('HLTX',Run3_2025)

# 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.custom_run3scouting_cff')
process.load('Configuration.StandardSequences.EndOfProcess_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(10000),
    output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
)

# Input source
process.source = cms.Source("PoolSource",
    fileNames = cms.untracked.vstring(
        'file:/eos/cms//store/mc/Run3Winter25Digi/GluGluToHHTo2B2Tau_Par-c2-0-kl-1-kt-1_TuneCP5_13p6TeV_powheg-pythia8/GEN-SIM-RAW/ggHH_powheg_bugfix_142X_mcRun3_2025_realistic_v7-v3/100000/0285a2a5-47b0-4576-a0d6-e16ac048a6c3.root'
        ),
    secondaryFileNames = cms.untracked.vstring()
)

process.options = cms.untracked.PSet(
    IgnoreCompletely = cms.untracked.vstring(),
    Rethrow = cms.untracked.vstring(),
    TryToContinue = 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,
    modulesToCallForTryToContinue = cms.untracked.vstring(),
    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('--python_filename nevts:10000'),
    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:nano_out.root'),
    outputCommands = process.NANOAODSIMEventContent.outputCommands
)

# Additional output definition

# Other statements
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, '142X_mcRun3_2025_realistic_v7', '')

# Path and EndPath definitions


# add mine: rerun HLT PNet a la https://github.com/cms-tau-pog/TauMLTools/blob/master/Production/python/customiseHLT.py#L359C1-L384C1
process.load('HLTrigger.Configuration.HLT_2024v14_cff')

process.HLTTauVertexSequencePF = cms.Sequence(
    process.hltVerticesPF
    + process.hltVerticesPFSelector
    + cms.ignore(process.hltVerticesPFFilter)
    + process.hltDeepInclusiveVertexFinderPF
    + process.hltDeepInclusiveSecondaryVerticesPF
)

process.HLTJetFlavourTagParticleNetSequencePFMod = cms.Sequence(
    process.hltVerticesPF
    + process.hltVerticesPFSelector
    + cms.ignore(process.hltVerticesPFFilter)
    + cms.ignore(process.hltPFJetForBtagSelector)
    + process.hltPFJetForBtag
    + process.hltDeepBLifetimeTagInfosPF
    + process.hltDeepInclusiveVertexFinderPF
    + process.hltDeepInclusiveSecondaryVerticesPF
    + process.hltDeepTrackVertexArbitratorPF
    + process.hltDeepInclusiveMergedVerticesPF
    + process.hltPrimaryVertexAssociation
    + process.hltParticleNetJetTagInfos
    + process.hltParticleNetONNXJetTags
    + process.hltParticleNetDiscriminatorsJetTags
)

process.hltPFJetForBtagSelector.MinPt = 15
process.hltPFJetForBtagSelector.MaxEta = 2.7
process.hltParticleNetJetTagInfos.min_jet_pt = 15
process.hltParticleNetJetTagInfos.max_jet_eta = 2.7

#process.scoutingNanoSequence.add(
process.nanoAOD_step = cms.Path(
    process.HLTL1UnpackerSequence
    + process.HLTBeamSpot
    # + process.HLTL2TauTagNNSequence
    # + process.HLTGlobalPFTauHPSSequence
    # + process.HLTHPSDeepTauPFTauSequenceForVBFIsoTau
    + process.HLTAK4PFJetsSequence
    + process.HLTJetFlavourTagParticleNetSequencePFMod
    # + process.HLTTauVertexSequencePF
    # + process.l1bits
    + process.scoutingNanoSequence
)

# process.schedule.insert(1000000, process.nanoAOD_step)
# process.nanoAOD_step = cms.Path(process.scoutingNanoSequence)
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 = 1
process.options.numberOfStreams = 0

# customisation of the process.

# Automatic addition of the customisation function from Configuration.DataProcessing.Utils
from Configuration.DataProcessing.Utils import addMonitoring 

#call to customisation function addMonitoring imported from Configuration.DataProcessing.Utils
process = addMonitoring(process)

# Automatic addition of the customisation function from PhysicsTools.NanoAOD.custom_run3scouting_cff
from PhysicsTools.NanoAOD.custom_run3scouting_cff import customiseScoutingNano 

#call to customisation function customiseScoutingNano imported from PhysicsTools.NanoAOD.custom_run3scouting_cff
process = customiseScoutingNano(process)

# End of customisation functions
process.load('PhysicsTools.NanoAOD.nano_cff')
from PhysicsTools.NanoAOD.common_cff import Var, P4Vars, ExtVar

# process.pfCandTable = cms.EDProducer("SimplePATCandidateFlatTableProducer",
#     src = cms.InputTag( "hltParticleFlow" ),
#     cut = cms.string(""),
#     name= cms.string("PFCand"),
#     doc = cms.string("HLT PF candidates"),
#     singleton = cms.bool(False), # the number of entries is variable
#     extension = cms.bool(False), # this is the main table
#     variables = cms.PSet(
#       P4Vars,
#       charge = Var("charge", int, doc="electric charge"),
#       vx = Var("vx", float, doc='x coordinate of vertex position'),
#       vy = Var("vy", float, doc='y coordinate of vertex position'),
#       vz = Var("vz", float, doc='z coordinate of vertex position'),
#       pdgId = Var("pdgId", int, doc='PDG identifier'),
#       longLived = Var("longLived", bool, doc='is long lived?'),
#       # source: cmssw/PhysicsTools/NanoAOD/plugins/SimpleFlatTableProducerPlugins.cc
#       trackDz = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.dz : -999.", float, doc = "track Dz"),
#       trackDxy = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.dxy : -999.", float, doc = "track Dxy"),
#       trackIsValid = Var("trackRef.isNonnull && trackRef.isAvailable", bool, doc = "track is valid"),
#       trackDzError = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.dzError : -999.", float, doc = "track DzError"),
#       trackDxyError = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.dxyError : -999.", float, doc = "track DxyError"),
#       trackPt = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.pt : -999.", float, doc = "track Pt"),
#       trackEta = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.eta : -999.", float, doc = "track Eta"),
#       trackPhi = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.phi : -999.", float, doc = "track Phi"),
#       trackPtError = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.ptError : -999.", float, doc = "track PtError"),
#       trackEtaError = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.etaError : -999.", float, doc = "track PtaError"),
#       trackPhiError = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.phiError : -999.", float, doc = "track PhiError"),
#       trackChi2 = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.chi2 : -999.", float, doc = "track Chi2"),
#       trackNdof = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.ndof : -999.", float, doc = "track Ndof"),
#       # source: DataFormats/TrackReco/interface/TrackBase.h
#       trackNumberOfValidHits = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.numberOfValidHits : -999.", float, doc = "number of valid hits found"),
#       trackNumberOfLostHits = Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.numberOfLostHits : -999.", float, doc = " number of cases where track crossed a layer without getting a hit."),
#       trackHitsValidFraction= Var("? trackRef.isNonnull && trackRef.isAvailable ? trackRef.validFraction : -999.", float, doc = "fraction of valid hits on the track"),
#       rawHcalEnergy = Var("rawHcalEnergy", float, doc='rawHcalEnergy'),
#       rawEcalEnergy = Var("rawEcalEnergy", float, doc='rawEcalEnergy'),
#       EcalEnergy = Var("ecalEnergy", float, doc='EcalEnergy'),
#       HcalEnergy = Var("hcalEnergy", float, doc='HcalEnergy'),
#     )
# )

process.AK4PFJetsTable = cms.EDProducer("SimplePFJetFlatTableProducer",
    src = cms.InputTag( "hltAK4PFJetsCorrected" ),
    cut = cms.string("pt > 10"),
    name= cms.string("hltAK4Jet"),
    doc = cms.string("HLT AK4 PF Jets"),
    singleton = cms.bool(False), # the number of entries is variable
    extension = cms.bool(False), # this is the main table
    variables = cms.PSet(
      P4Vars,
      chargedHadronEnergy = Var("chargedHadronEnergy", float, doc = "chargedHadronEnergy"),
      chargedHadronEnergyFraction = Var("chargedHadronEnergyFraction", float, doc = "chargedHadronEnergyFraction"),
      neutralHadronEnergy = Var("neutralHadronEnergy", float, doc = "neutralHadronEnergy"),
      neutralHadronEnergyFraction = Var("neutralHadronEnergyFraction", float, doc = "neutralHadronEnergyFraction"),
      photonEnergy = Var("photonEnergy", float, doc = "photonEnergy"),
      photonEnergyFraction = Var("photonEnergyFraction", float, doc = "photonEnergyFraction"),
      muonEnergy = Var("muonEnergy", float, doc = "muonEnergy"),
      muonEnergyFraction = Var("muonEnergyFraction", float, doc = "muonEnergyFraction"),
      HFHadronEnergy = Var("HFHadronEnergy", float, doc = "HFHadronEnergy"),
      HFHadronEnergyFraction = Var("HFHadronEnergyFraction", float, doc = "HFHadronEnergyFraction"),
      HFEMEnergy = Var("HFEMEnergy", float, doc = "HFEMEnergy"),
      HFEMEnergyFraction = Var("HFEMEnergyFraction", float, doc = "HFEMEnergyFraction"),
      chargedHadronMultiplicity = Var("chargedHadronMultiplicity", float, doc = "chargedHadronMultiplicity"),
      neutralHadronMultiplicity = Var("neutralHadronMultiplicity", float, doc = "neutralHadronMultiplicity"),
      photonMultiplicity = Var("photonMultiplicity", float, doc = "photonMultiplicity"),
      muonMultiplicity = Var("muonMultiplicity", float, doc = "muonMultiplicity"),
      HFHadronMultiplicity = Var("HFHadronMultiplicity", float, doc = "HFHadronMultiplicity"),
      HFEMMultiplicity = Var("HFEMMultiplicity", float, doc = "HFEMMultiplicity"),
      chargedMuEnergy = Var("chargedMuEnergy", float, doc = "chargedMuEnergy"),
      chargedMuEnergyFraction = Var("chargedMuEnergyFraction", float, doc = "chargedMuEnergyFraction"),
      neutralEmEnergy = Var("neutralEmEnergy", float, doc = "neutralEmEnergy"),
      neutralEmEnergyFraction = Var("neutralEmEnergyFraction", float, doc = "neutralEmEnergyFraction"),
      chargedMultiplicity = Var("chargedMultiplicity", float, doc = "chargedMultiplicity"),
      neutralMultiplicity = Var("neutralMultiplicity", float, doc = "neutralMultiplicity"),
      nConstituents = Var("nConstituents", int, doc = "nConstituents"),
      etaetaMoment =  Var("etaetaMoment", float, doc = " eta-eta second moment, ET weighted " ),
      phiphiMoment =  Var("phiphiMoment", float, doc = " phi-phi second moment, ET weighted " ),
      etaphiMoment =  Var("etaphiMoment", float, doc = " eta-phi second moment, ET weighted " ),
      maxDistance =  Var("maxDistance", float, doc = " maximum distance from jet to constituent " ),
      constituentPtDistribution =  Var("constituentPtDistribution", float, doc = " jet structure variables: constituentPtDistribution is the pT distribution among the jet constituents (ptDistribution = 1 if jet made by one constituent carrying all its momentum,  ptDistribution = 0 if jet made by infinite constituents carrying an infinitesimal fraction of pt) "    ),
      constituentEtaPhiSpread =  Var("constituentEtaPhiSpread", float, doc = " the rms of the eta-phi spread of the jet's constituents wrt the jet axis " ),
      jetArea =  Var("jetArea", float, doc = " get jet area " ),
    )
)

pnet_discriminator_names = ["BvsAll", "CvsAll", "CvsL", "TauhvsAll"]
pnet_score_names = ["probb","probc","probuds","probg","probtauhp","probtauhm","ptcorr"]

process.hltPFJetForBtagPAT = cms.EDProducer("PATJetProducer",
    jetSource = cms.InputTag("hltPFJetForBtag"),  # Input HLT jets
    addJetCorrFactors = cms.bool(False),  # No JEC applied
    addBTagInfo = cms.bool(True),
    discriminatorSources = cms.VInputTag(
        # cms.InputTag("hltParticleNetDiscriminatorsJetTags", "BvsAll"),
        # cms.InputTag("hltParticleNetDiscriminatorsJetTags", "CvsAll"),
        # cms.InputTag("hltParticleNetDiscriminatorsJetTags", "CvsL"),
        # cms.InputTag("hltParticleNetDiscriminatorsJetTags", "TauhvsAll"),
        # ## raw scores
        # cms.InputTag("hltParticleNetONNXJetTags", "probb"),
        # cms.InputTag("hltParticleNetONNXJetTags", "probc"),
        # cms.InputTag("hltParticleNetONNXJetTags", "probuds"),
        # cms.InputTag("hltParticleNetONNXJetTags", "probg"),
        # cms.InputTag("hltParticleNetONNXJetTags", "probtauhp"),
        # cms.InputTag("hltParticleNetONNXJetTags", "probtauhm"),
        # cms.InputTag("hltParticleNetONNXJetTags", "ptcorr"),
        
        # compact form
        *[cms.InputTag("hltParticleNetDiscriminatorsJetTags", name) for name in pnet_discriminator_names],
        *[cms.InputTag("hltParticleNetONNXJetTags", name) for name in pnet_score_names],

    ),
    addDiscriminators = cms.bool(True),
    addJetCharge = cms.bool(False),
    addGenPartonMatch = cms.bool(False),
    addAssociatedTracks = cms.bool(False),
    addGenJetMatch = cms.bool(False),
    getJetMCFlavour = cms.bool(False),
    addJetFlavourInfo = cms.bool(False),
)

process.hltPFJetForBtagTable = cms.EDProducer("SimplePATJetFlatTableProducer",
    src = cms.InputTag( "hltPFJetForBtagPAT" ),
    name= cms.string("hltAK4JetPNet"),
    doc = cms.string("HLT AK4 PF Jets w PNet"),
    singleton = cms.bool(False), # the number of entries is variable
    extension = cms.bool(False), # this is the main table
    variables = cms.PSet(
        process.AK4PFJetsTable.variables,
        btagPNetB = Var("bDiscriminator('hltParticleNetDiscriminatorsJetTags:BvsAll')",float, doc="BvsAll"),
        btagPNetC = Var("bDiscriminator('hltParticleNetDiscriminatorsJetTags:CvsAll')",float, doc="CvsAll"),
        btagPNetCvsL = Var("bDiscriminator('hltParticleNetDiscriminatorsJetTags:CvsL')",float, doc="CvsL"),
        btagPNetTauVJet = Var("bDiscriminator('hltParticleNetDiscriminatorsJetTags:TauhvsAll')",float, doc="TauVsJet"),
        # raw scores
        btagPNet_probb = Var("bDiscriminator('hltParticleNetONNXJetTags:probb')",float, doc="probb"),
        btagPNet_probc = Var("bDiscriminator('hltParticleNetONNXJetTags:probc')",float, doc="probc"),
        btagPNet_probuds = Var("bDiscriminator('hltParticleNetONNXJetTags:probuds')",float, doc="probuds"),
        btagPNet_probg = Var("bDiscriminator('hltParticleNetONNXJetTags:probg')",float, doc="probg"),
        btagPNet_probtauhp = Var("bDiscriminator('hltParticleNetONNXJetTags:probtauhp')",float, doc="probtauhp"),
        btagPNet_probtauhm = Var("bDiscriminator('hltParticleNetONNXJetTags:probtauhm')",float, doc="probtauhm"),
        btagPNet_ptcorr = Var("bDiscriminator('hltParticleNetONNXJetTags:ptcorr')",float, doc="ptcorr"),

        # compact form - wip
        # **{f"btagPNet{name}": Var( f"bDiscriminator('hltParticleNetDiscriminatorsJetTags:{name}')",
        #                           float, doc = f"ParticleNet {name} discriminator", precision = 10,
        #                           ) for name in pnet_discriminator_names},

        # **{f"btagPNet_{name}": Var( f"bDiscriminator('hltParticleNetONNXJetTags:{name}')", 
        #                            float, doc = f"ParticleNet {name} discriminator", precision = 10,
        #                            ) for name in pnet_score_names},
    ),
)

## PV – WIP
## a la TauML
# process.pfVertexTable = cms.EDProducer("VertexTableProducerHLT",
#     src = cms.InputTag("hltVerticesPF"),
#     name = cms.string("PFPrimaryVertex")
#   )

## a la nano
# process.pfVertexTable = process.vertexTable.clone(
#     pvSrc = cms.InputTag("hltVerticesPF"),
#     goodPvCut = cms.string(""), 
#     pfcSrc = cms.InputTag("hltParticleFlow"),
#     svSrc = cms.InputTag('hltDeepInclusiveSecondaryVerticesPF'),
# )

# copy from default nano
process.svCandidateTable.src = 'hltDeepInclusiveSecondaryVerticesPF'
process.svCandidateTable.name = 'hltPFSecondaryVertex'
process.svCandidateTable.extension = False

process.scoutingTriggerTask.add(
    # process.pfCandTable,
    process.AK4PFJetsTable,

    ## pnet jets
    process.hltPFJetForBtagPAT,
    process.hltPFJetForBtagTable,

    ## vertices
    # process.pfVertexTable, # wip
    process.svCandidateTable,
    )

# for running on RAW
# process.scoutingNanoTaskMC.remove(process.puTable) 
process.scoutingNanoSequence.remove(process.scoutingNanoTaskMC)

# 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