processingMode=cms.untracked.string('RunsAndLumis'))
process.options = cms.untracked.PSet(
Rethrow=cms.untracked.vstring('ProductNotFound'),
fileMode=cms.untracked.string('FULLMERGE'))
elements = c.createElements()
process.harvester = cms.EDAnalyzer("DummyHarvestingClient",
folder=cms.untracked.string(folder),
elements=cms.untracked.VPSet(*elements),
cumulateRuns=cms.untracked.bool(False),
cumulateLumis=cms.untracked.bool(True))
process.eff = DQMEDHarvester("DQMGenericClient",
efficiency=cms.vstring("eff1 \'Eff1\' Bar0 Bar1"),
resolution=cms.vstring(),
subDirs=cms.untracked.vstring(folder))
process.dqmSaver.workflow = cms.untracked.string(
"/Test/Merged_File1_File2_oldf/DQM")
process.dqmSaver.saveByLumiSection = cms.untracked.int32(1)
process.dqmSaver.saveByRun = cms.untracked.int32(1)
process.p = cms.Path(process.EDMtoME + process.harvester + process.eff)
process.o = cms.EndPath(process.dqmSaver)
process.add_(cms.Service("DQMStore"))
process.DQMStore.verbose = cms.untracked.int32(3)
#process.add_(cms.Service("Tracer"))
)
SiPixelPhase1HitsAnalyzerV = cms.EDAnalyzer(
"SiPixelPhase1HitsV",
pixBarrelLowSrc=cms.InputTag("g4SimHits", "TrackerHitsPixelBarrelLowTof"),
pixBarrelHighSrc=cms.InputTag("g4SimHits",
"TrackerHitsPixelBarrelHighTof"),
pixForwardLowSrc=cms.InputTag("g4SimHits", "TrackerHitsPixelEndcapLowTof"),
pixForwardHighSrc=cms.InputTag("g4SimHits",
"TrackerHitsPixelEndcapHighTof"),
# Hit Efficiency stuff
associateRecoTracks=cms.bool(True),
tracksTag=cms.InputTag("generalTracks"),
tpTag=cms.InputTag("mix", "MergedTrackTruth"),
trackAssociatorByHitsTag=cms.InputTag("quickTrackAssociatorByHits"),
associateStrip=cms.bool(True),
associatePixel=cms.bool(True),
ROUList=cms.vstring('g4SimHitsTrackerHitsPixelBarrelLowTof',
'g4SimHitsTrackerHitsPixelBarrelHighTof',
'g4SimHitsTrackerHitsPixelEndcapLowTof',
'g4SimHitsTrackerHitsPixelEndcapHighTof'),
# Track assoc. parameters
histograms=SiPixelPhase1HitsConf,
geometry=SiPixelPhase1Geometry)
SiPixelPhase1HitsHarvesterV = DQMEDHarvester("SiPixelPhase1Harvester",
histograms=SiPixelPhase1HitsConf,
geometry=SiPixelPhase1Geometry)
hfupsilon = heavyFlavorValidationHarvesting.clone(
MyDQMrootFolder = cms.untracked.string(baseFolderPath + 'HLT_Dimuon12_Upsilon_eta1p5_v')
)
combiner = DQMEDHarvester('PlotCombiner',
MyDQMrootFolder = cms.untracked.string('HLT/BPH/HLT'),
Plots = cms.untracked.VPSet(
cms.untracked.PSet(
InputMEnames = cms.untracked.vstring(
'HLT_DoubleMu4_3_Bs_v/effPathDiglobAND_recoEtaPtY',
'HLT_DoubleMu4_3_Jpsi_Displaced_v/effPathDiglobAND_recoEtaPtY',
'HLT_DoubleMu4_JpsiTrk_Displaced_v/effPathDiglobAND_recoEtaPtY',
'HLT_DoubleMu4_PsiPrimeTrk_Displaced_v/effPathDiglobAND_recoEtaPtY',
'HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v/effPathDiglobAND_recoEtaPtY',
),
InputLabels = cms.untracked.vstring(
'HLT_DoubleMu4_3_Bs_v',
'HLT_DoubleMu4_3_Jpsi_Displaced_v',
'HLT_DoubleMu4_JpsiTrk_Displaced_v',
'HLT_DoubleMu4_PsiPrimeTrk_Displaced_v',
'HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v',
),
OutputMEname = cms.untracked.string('effPathGlob_recoLowPt')
)
)
)
combiner2 = combiner.clone(
Plots = cms.untracked.VPSet(
cms.untracked.PSet(
InputMEnames = cms.untracked.vstring(
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
dtChamberEfficiencyClient = DQMEDHarvester("DTChamberEfficiencyClient",
diagnosticPrescale = cms.untracked.int32(1))
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
# directory path shortening
bmtfDqmDir = 'L1T/L1TStage2BMTF'
bmtfZSDqmDir = bmtfDqmDir+'/zeroSuppression'
errHistNumStr = 'errorSummaryNum'
errHistDenStr = 'errorSummaryDen'
# zero suppression
l1tStage2BmtfZeroSuppRatioClient = DQMEDHarvester("L1TStage2RatioClient",
monitorDir = cms.untracked.string(bmtfZSDqmDir+'/AllEvts'),
inputNum = cms.untracked.string(bmtfZSDqmDir+'/AllEvts/'+errHistNumStr),
inputDen = cms.untracked.string(bmtfZSDqmDir+'/AllEvts/'+errHistDenStr),
ratioName = cms.untracked.string('mismatchRatio'),
ratioTitle = cms.untracked.string('Summary of bad zero suppression rates'),
yAxisTitle = cms.untracked.string('# fail / # total'),
binomialErr = cms.untracked.bool(True)
)
l1tStage2BmtfZeroSuppFatEvtsRatioClient = l1tStage2BmtfZeroSuppRatioClient.clone()
l1tStage2BmtfZeroSuppFatEvtsRatioClient.monitorDir = cms.untracked.string(bmtfZSDqmDir+'/FatEvts')
l1tStage2BmtfZeroSuppFatEvtsRatioClient.inputNum = cms.untracked.string(bmtfZSDqmDir+'/FatEvts/'+errHistNumStr)
l1tStage2BmtfZeroSuppFatEvtsRatioClient.inputDen = cms.untracked.string(bmtfZSDqmDir+'/FatEvts/'+errHistDenStr)
l1tStage2BmtfZeroSuppFatEvtsRatioClient.ratioTitle = cms.untracked.string('Summary of bad zero suppression rates')
# sequences
l1tStage2BmtfZeroSuppCompClient = cms.Sequence(
l1tStage2BmtfZeroSuppRatioClient
+ l1tStage2BmtfZeroSuppFatEvtsRatioClient
)
from DQM.L1TMonitor.L1TStage2uGMT_cff import ignoreBins
# directory path shortening
ugmtDqmDir = 'L1T/L1TStage2uGMT'
ugmtMuCpyDqmDir = ugmtDqmDir+'/uGMTMuonCopies'
ugmtZSDqmDir = ugmtDqmDir+'/zeroSuppression'
# input histograms
errHistNumStr = 'errorSummaryNum'
errHistDenStr = 'errorSummaryDen'
# Muons
l1tStage2uGMTOutVsuGTInRatioClient = DQMEDHarvester("L1TStage2RatioClient",
monitorDir = cms.untracked.string(ugmtDqmDir+'/uGMToutput_vs_uGTinput'),
inputNum = cms.untracked.string(ugmtDqmDir+'/uGMToutput_vs_uGTinput/'+errHistNumStr),
inputDen = cms.untracked.string(ugmtDqmDir+'/uGMToutput_vs_uGTinput/'+errHistDenStr),
ratioName = cms.untracked.string('mismatchRatio'),
ratioTitle = cms.untracked.string('Summary of mismatch rates between uGMT output muons and uGT input muons'),
yAxisTitle = cms.untracked.string('# mismatch / # total'),
binomialErr = cms.untracked.bool(True)
)
l1tStage2uGMTMuonVsuGMTMuonCopy1RatioClient = l1tStage2uGMTOutVsuGTInRatioClient.clone()
l1tStage2uGMTMuonVsuGMTMuonCopy1RatioClient.monitorDir = cms.untracked.string(ugmtMuCpyDqmDir+'/uGMTMuonCopy1')
l1tStage2uGMTMuonVsuGMTMuonCopy1RatioClient.inputNum = cms.untracked.string(ugmtMuCpyDqmDir+'/uGMTMuonCopy1/'+errHistNumStr)
l1tStage2uGMTMuonVsuGMTMuonCopy1RatioClient.inputDen = cms.untracked.string(ugmtMuCpyDqmDir+'/uGMTMuonCopy1/'+errHistDenStr)
l1tStage2uGMTMuonVsuGMTMuonCopy1RatioClient.ratioTitle = cms.untracked.string('Summary of mismatch rates between uGMT muons and uGMT muon copy 1')
l1tStage2uGMTMuonVsuGMTMuonCopy2RatioClient = l1tStage2uGMTOutVsuGTInRatioClient.clone()
l1tStage2uGMTMuonVsuGMTMuonCopy2RatioClient.monitorDir = cms.untracked.string(ugmtMuCpyDqmDir+'/uGMTMuonCopy2')
l1tStage2uGMTMuonVsuGMTMuonCopy2RatioClient.inputNum = cms.untracked.string(ugmtMuCpyDqmDir+'/uGMTMuonCopy2/'+errHistNumStr)
l1tStage2uGMTMuonVsuGMTMuonCopy2RatioClient.inputDen = cms.untracked.string(ugmtMuCpyDqmDir+'/uGMTMuonCopy2/'+errHistDenStr)
l1tStage2EventInfoClient = DQMEDHarvester(
"L1TEventInfoClient",
monitorDir=cms.untracked.string("L1T"),
# decide when to run and update the results of the quality tests
# retrieval of quality test results must be consistent with the event / LS / Run execution
#
runInEventLoop=cms.untracked.bool(False),
runInEndLumi=cms.untracked.bool(True),
runInEndRun=cms.untracked.bool(True),
runInEndJob=cms.untracked.bool(False),
#
# for each L1 system, give:
# - SystemLabel: system label
# - HwValLabel: system label as used in hardware validation package
# (the package producing the ErrorFlag histogram)
# - SystemDisable: system disabled: if 1, all quality tests for the system
# are disabled in the summary plot
# - for each quality test:
# - QualityTestName: name of quality test
# - QualityTestHist: histogram (full path)
# - QualityTestSummaryEnabled: 0 if disabled, 1 if enabled in summary plot
#
# the position in the parameter set gives, in reverse order, the position in the reportSummaryMap
# in the emulator column (left column)
L1Systems=cms.VPSet(
cms.PSet(
SystemLabel=cms.string("ECAL_TPG"),
HwValLabel=cms.string("ETP"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("Layer1LinkErrorThreshold"),
QualityTestHist=cms.string(
"L1T/L1TStage2CaloLayer1/MismatchDetail/maxEvtLinkErrorsByLumiECAL"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("Layer1MismatchThreshold"),
QualityTestHist=cms.string(
"L1T/L1TStage2CaloLayer1/MismatchDetail/maxEvtMismatchByLumiECAL"
),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(
SystemLabel=cms.string("HCAL_TPG"),
HwValLabel=cms.string("HTP"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("Layer1LinkErrorThreshold"),
QualityTestHist=cms.string(
"L1T/L1TStage2CaloLayer1/MismatchDetail/maxEvtLinkErrorsByLumiHCAL"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("Layer1MismatchThreshold"),
QualityTestHist=cms.string(
"L1T/L1TStage2CaloLayer1/MismatchDetail/maxEvtMismatchByLumiHCAL"
),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(
SystemLabel=cms.string("Calo Layer1"),
HwValLabel=cms.string("Stage2CaloLayer1"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("Layer1LinkErrorThreshold"),
QualityTestHist=cms.string(
"L1T/L1TStage2CaloLayer1/maxEvtLinkErrorsByLumi"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("Layer1MismatchThreshold"),
QualityTestHist=cms.string(
"L1T/L1TStage2CaloLayer1/maxEvtMismatchByLumi"),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(SystemLabel=cms.string("Calo Layer2"),
HwValLabel=cms.string("Stage2CaloLayer2"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(
SystemLabel=cms.string("BMTF"),
HwValLabel=cms.string("Stage2BMTF"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("BMTF_hwPtRange"),
QualityTestHist=cms.string("L1T/L1TStage2BMTF/bmtf_hwPt"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("BMTF_WedgeBXNoisyWedge"),
QualityTestHist=cms.string(
"L1T/L1TStage2BMTF/bmtf_wedge_bx"),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(
SystemLabel=cms.string("OMTF"),
HwValLabel=cms.string("Stage2OMTF"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("OMTF_bXPeakAtBX0"),
QualityTestHist=cms.string("L1T/L1TStage2OMTF/omtf_bx"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("OMTF_bXMeanAtBX0"),
QualityTestHist=cms.string("L1T/L1TStage2OMTF/omtf_bx"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("OMTF_hwPtRange"),
QualityTestHist=cms.string("L1T/L1TStage2OMTF/omtf_hwPt"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("OMTF_hwEtaRange"),
QualityTestHist=cms.string("L1T/L1TStage2OMTF/omtf_hwEta"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("OMTF_hwEtaMeanAt0"),
QualityTestHist=cms.string("L1T/L1TStage2OMTF/omtf_hwEta"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("OMTF_hwLocalPhiRange"),
QualityTestHist=cms.string(
"L1T/L1TStage2OMTF/omtf_hwLocalPhi"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("OMTF_hwQualRange"),
QualityTestHist=cms.string(
"L1T/L1TStage2OMTF/omtf_hwQual"),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(
SystemLabel=cms.string("EMTF"),
HwValLabel=cms.string("Stage2EMTF"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("EMTF_LCTOccupancyDeadChamber"),
QualityTestHist=cms.string(
"L1T/L1TStage2EMTF/cscLCTOccupancy"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string(
"EMTF_LCTOccupancyNoisyChamber"),
QualityTestHist=cms.string(
"L1T/L1TStage2EMTF/cscLCTOccupancy"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("EMTF_TrackBXNoisyTrack"),
QualityTestHist=cms.string(
"L1T/L1TStage2EMTF/emtfTrackBX"),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(
SystemLabel=cms.string("uGMT"),
HwValLabel=cms.string("Stage2uGMT"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
#cms.PSet(
# QualityTestName = cms.string("uGMT_MuonBXPeakAtBX0"),
# QualityTestHist = cms.string("L1T/L1TStage2uGMT/ugmtMuonBX"),
# QualityTestSummaryEnabled = cms.uint32(1)
# ),
cms.PSet(
QualityTestName=cms.string("uGMT_MuonBXMeanAtBX0"),
QualityTestHist=cms.string("L1T/L1TStage2uGMT/ugmtMuonBX"),
QualityTestSummaryEnabled=cms.uint32(1)),
#cms.PSet(
# QualityTestName = cms.string("uGMT_BMTFBXPeakAtBX0"),
# QualityTestHist = cms.string("L1T/L1TStage2uGMT/BMTFInput/ugmtBMTFBX"),
# QualityTestSummaryEnabled = cms.uint32(1)
# ),
cms.PSet(QualityTestName=cms.string("uGMT_BMTFBXMeanAtBX0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/BMTFInput/ugmtBMTFBX"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("uGMT_BMTFhwPhiSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/BMTFInput/ugmtBMTFglbhwPhi"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("uGMT_BMTFhwEtaSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/BMTFInput/ugmtBMTFhwEta"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("uGMT_BMTFhwEtaMeanAt0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/BMTFInput/ugmtBMTFhwEta"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("uGMT_BMTFhwSignUniform"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/BMTFInput/ugmtBMTFhwSign"),
QualityTestSummaryEnabled=cms.uint32(1)),
#cms.PSet(
# QualityTestName = cms.string("uGMT_OMTFBXPeakAtBX0"),
# QualityTestHist = cms.string("L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFBX"),
# QualityTestSummaryEnabled = cms.uint32(1)
# ),
cms.PSet(QualityTestName=cms.string("uGMT_OMTFBXMeanAtBX0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFBX"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("uGMT_OMTFhwPhiPosSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFglbhwPhiPos"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(
QualityTestName=cms.string("uGMT_OMTFhwPhiNegSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFglbhwPhiNeg"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("uGMT_OMTFhwEtaSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFhwEta"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("uGMT_OMTFhwEtaMeanAt0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFhwEta"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("uGMT_OMTFhwPtRange"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFhwPt"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("uGMT_OMTFhwSignUniform"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/OMTFInput/ugmtOMTFhwSign"),
QualityTestSummaryEnabled=cms.uint32(1)),
#cms.PSet(
# QualityTestName = cms.string("uGMT_EMTFBXPeakAtBX0"),
# QualityTestHist = cms.string("L1T/L1TStage2uGMT/EMTFInput/ugmtEMTFBX"),
# QualityTestSummaryEnabled = cms.uint32(1)
# ),
cms.PSet(QualityTestName=cms.string("uGMT_EMTFBXMeanAtBX0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/EMTFInput/ugmtEMTFBX"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("uGMT_EMTFMuonPhiSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonPhiEmtf"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("uGMT_EMTFMuonPhiMeanAt0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonPhiEmtf"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("uGMT_EMTFhwSignUniform"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/EMTFInput/ugmtEMTFhwSign"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("BMTFvsuGMT_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/BMTFoutput_vs_uGMTinput/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
#cms.PSet(
# QualityTestName = cms.string("EMTFvsuGMT_MismatchRatioMax0"),
# QualityTestHist = cms.string("L1T/L1TStage2uGMT/EMTFoutput_vs_uGMTinput/mismatchRatio"),
# QualityTestSummaryEnabled = cms.uint32(1)
# ),
cms.PSet(
QualityTestName=cms.string("uGMTCopies_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/uGMTMuonCopies/GMTMuonCopy1/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("uGMTCopies_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/uGMTMuonCopies/uGMTMuonCopy2/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("uGMTCopies_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/uGMTMuonCopies/uGMTMuonCopy3/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("uGMTCopies_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/uGMTMuonCopies/uGMTMuonCopy4/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("uGMTCopies_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/uGMTMuonCopies/uGMTMuonCopy5/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("zeroSupp_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/zeroSuppression/AllEvts/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("zeroSupp_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/zeroSuppression/FatEvts/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(
SystemLabel=cms.string("uGT"),
HwValLabel=cms.string("Stage2uGT"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("uGMTvsuGT_MismatchRatioMax0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGT/uGMToutput_vs_uGTinput/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)), ))),
#
# for each L1 trigger object, give:
# - ObjectLabel: object label as used in enum L1GtObject
# - ObjectDisable: emulator mask: if 1, the system is masked in the summary plot
#
# the position in the parameter set gives, in reverse order, the position in the reportSummaryMap
# in the trigger object column (right column)
L1Objects=cms.VPSet(
cms.PSet(ObjectLabel=cms.string("TechTrig"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("GtExternal"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("HfRingEtSums"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("HfBitCounts"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("HTM"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("HTT"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("ETM"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("ETT"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("Tau"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("ForJet"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("CenJet"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("IsoEG"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(ObjectLabel=cms.string("NoIsoEG"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet()),
cms.PSet(
ObjectLabel=cms.string("Mu"),
ObjectDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(QualityTestName=cms.string("muon_etaMeanAt0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonEta"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("muon_etaSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonEta"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("muon_etaMeanAt0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonEtaAtVtx"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("muon_etaSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonEtaAtVtx"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("muon_phiMeanAt0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonPhi"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("muon_phiSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonPhi"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(QualityTestName=cms.string("muon_phiMeanAt0"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonPhiAtVtx"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(QualityTestName=cms.string("muon_phiSpectrum"),
QualityTestHist=cms.string(
"L1T/L1TStage2uGMT/ugmtMuonPhiAtVtx"),
QualityTestSummaryEnabled=cms.uint32(0)),
cms.PSet(
QualityTestName=cms.string("muon_PtRange"),
QualityTestHist=cms.string("L1T/L1TStage2uGMT/ugmtMuonPt"),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string("muon_PtSpectrum"),
QualityTestHist=cms.string("L1T/L1TStage2uGMT/ugmtMuonPt"),
QualityTestSummaryEnabled=cms.uint32(0)),
),
),
),
#
# fast over-mask a system: if the name of the system is in the list, the system will be masked
# (the default mask value is given in L1Systems VPSet)
#
DisableL1Systems=cms.vstring(),
#
# fast over-mask an object: if the name of the object is in the list, the object will be masked
# (the default mask value is given in L1Objects VPSet)
#
DisableL1Objects=cms.vstring())
# directories
ugmtEmuDqmDir = "L1TEMU/L1TdeStage2uGMT"
ugmtEmuDEDqmDir = ugmtEmuDqmDir + "/data_vs_emulator_comparison"
ugmtEmuImdMuDqmDir = ugmtEmuDqmDir + "/intermediate_muons"
# input histograms
errHistNumStr = 'errorSummaryNum'
errHistDenStr = 'errorSummaryDen'
# Muons
l1tStage2uGMTEmulatorCompRatioClient = DQMEDHarvester(
"L1TStage2RatioClient",
monitorDir=cms.untracked.string(ugmtEmuDEDqmDir),
inputNum=cms.untracked.string(ugmtEmuDEDqmDir + '/' + errHistNumStr),
inputDen=cms.untracked.string(ugmtEmuDEDqmDir + '/' + errHistDenStr),
ratioName=cms.untracked.string('mismatchRatio'),
ratioTitle=cms.untracked.string(
'Summary of mismatch rates between uGMT muons and uGMT emulator muons'
),
yAxisTitle=cms.untracked.string('# mismatch / # total'),
binomialErr=cms.untracked.bool(True))
# intermediate muons
titleStr = 'Summary of mismatch rates between uGMT intermediate muons and uGMT emulator intermediate muons from '
l1tStage2uGMTEmulImdMuBMTFCompRatioClient = l1tStage2uGMTEmulatorCompRatioClient.clone(
)
l1tStage2uGMTEmulImdMuBMTFCompRatioClient.monitorDir = cms.untracked.string(
ugmtEmuImdMuDqmDir + '/BMTF/data_vs_emulator_comparison')
l1tStage2uGMTEmulImdMuBMTFCompRatioClient.inputNum = cms.untracked.string(
ugmtEmuImdMuDqmDir + '/BMTF/data_vs_emulator_comparison/' + errHistNumStr)
l1tStage2uGMTEmulImdMuBMTFCompRatioClient.inputDen = cms.untracked.string(
inputNum = cms.untracked.string(ugtDqmDir+'/uGMToutput_vs_uGTinput/'+errHistNumStr),
inputDen = cms.untracked.string(ugtDqmDir+'/uGMToutput_vs_uGTinput/'+errHistDenStr),
ignoreBin = cms.untracked.vint32(l1tStage2uGMTOutVsuGTIn.ignoreBin),
ratioName = cms.untracked.string('mismatchRatio'),
ratioTitle = cms.untracked.string('Summary of mismatch rates between uGMT output muons and uGT input muons'),
yAxisTitle = cms.untracked.string('# mismatch / # total'),
binomialErr = cms.untracked.bool(True)
)
## uGT Board Comparisons
l1tStage2uGTMuon1vsMuon2RatioClient = DQMEDHarvester("L1TStage2RatioClient",
monitorDir = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard2/Muons'),
inputNum = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard2/Muons/'+errHistNumStr),
inputDen = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard2/Muons/'+errHistDenStr),
ratioName = cms.untracked.string('mismatchRatio'),
ratioTitle = cms.untracked.string('Summary of Mismatch Rates between Muons from uGT Board 1 and uGT Board 2'),
yAxisTitle = cms.untracked.string('# mismatch / # total'),
binomialErr = cms.untracked.bool(True)
)
l1tStage2uGTMuon1vsMuon3RatioClient = l1tStage2uGTMuon1vsMuon2RatioClient.clone()
l1tStage2uGTMuon1vsMuon3RatioClient.monitorDir = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard3/Muons')
l1tStage2uGTMuon1vsMuon3RatioClient.inputNum = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard3/Muons/'+errHistNumStr)
l1tStage2uGTMuon1vsMuon3RatioClient.inputDen = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard3/Muons/'+errHistDenStr)
l1tStage2uGTMuon1vsMuon3RatioClient.ratioTitle = cms.untracked.string('Summary of Mismatch Rates between Muons from uGT Board 1 and uGT Board 3')
l1tStage2uGTMuon1vsMuon4RatioClient = l1tStage2uGTMuon1vsMuon2RatioClient.clone()
l1tStage2uGTMuon1vsMuon4RatioClient.monitorDir = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard4/Muons')
l1tStage2uGTMuon1vsMuon4RatioClient.inputNum = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard4/Muons/'+errHistNumStr)
l1tStage2uGTMuon1vsMuon4RatioClient.inputDen = cms.untracked.string(ugtBoardCompDqmDir+'/Board1vsBoard4/Muons/'+errHistDenStr)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from DQMOffline.EGamma.photonAnalyzer_cfi import *
photonOfflineClient = DQMEDHarvester(
"PhotonOfflineClient",
ComponentName=cms.string('photonOfflineClient'),
analyzerName=cms.string('gedPhotonAnalyzer'),
standAlone=cms.bool(False),
batch=cms.bool(False),
cutStep=photonAnalysis.cutStep,
numberOfSteps=photonAnalysis.numberOfSteps,
minimalSetOfHistos=photonAnalysis.minimalSetOfHistos,
excludeBkgHistos=photonAnalysis.excludeBkgHistos,
etBin=photonAnalysis.etBin,
etMin=photonAnalysis.etMin,
etMax=photonAnalysis.etMax,
etaBin=photonAnalysis.etaBin,
etaMin=photonAnalysis.etaMin,
etaMax=photonAnalysis.etaMax,
phiBin=photonAnalysis.phiBin,
phiMin=photonAnalysis.phiMin,
phiMax=photonAnalysis.phiMax,
InputFileName=cms.untracked.string("DQMOfflinePhotonsBatch.root"),
OutputFileName=cms.string('DQMOfflinePhotonsAfterSecondStep.root'),
)
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
# directories
ugmtEmuDqmDir = "L1TEMU/L1TdeStage2uGMT"
ugmtEmuDEDqmDir = ugmtEmuDqmDir+"/data_vs_emulator_comparison"
ugmtEmuImdMuDqmDir = ugmtEmuDqmDir+"/intermediate_muons"
# input histograms
errHistNumStr = 'errorSummaryNum'
errHistDenStr = 'errorSummaryDen'
# Muons
l1tStage2uGMTEmulatorCompRatioClient = DQMEDHarvester("L1TStage2RatioClient",
monitorDir = cms.untracked.string(ugmtEmuDEDqmDir),
inputNum = cms.untracked.string(ugmtEmuDEDqmDir+'/'+errHistNumStr),
inputDen = cms.untracked.string(ugmtEmuDEDqmDir+'/'+errHistDenStr),
ratioName = cms.untracked.string('mismatchRatio'),
ratioTitle = cms.untracked.string('Summary of mismatch rates between uGMT muons and uGMT emulator muons'),
yAxisTitle = cms.untracked.string('# mismatch / # total'),
binomialErr = cms.untracked.bool(True)
)
# intermediate muons
titleStr = 'Summary of mismatch rates between uGMT intermediate muons and uGMT emulator intermediate muons from '
l1tStage2uGMTEmulImdMuBMTFCompRatioClient = l1tStage2uGMTEmulatorCompRatioClient.clone()
l1tStage2uGMTEmulImdMuBMTFCompRatioClient.monitorDir = cms.untracked.string(ugmtEmuImdMuDqmDir+'/BMTF/data_vs_emulator_comparison')
l1tStage2uGMTEmulImdMuBMTFCompRatioClient.inputNum = cms.untracked.string(ugmtEmuImdMuDqmDir+'/BMTF/data_vs_emulator_comparison/'+errHistNumStr)
l1tStage2uGMTEmulImdMuBMTFCompRatioClient.inputDen = cms.untracked.string(ugmtEmuImdMuDqmDir+'/BMTF/data_vs_emulator_comparison/'+errHistDenStr)
l1tStage2uGMTEmulImdMuBMTFCompRatioClient.ratioTitle = cms.untracked.string(titleStr+'BMTF')
l1tStage2uGMTEmulImdMuOMTFNegCompRatioClient = l1tStage2uGMTEmulatorCompRatioClient.clone()
l1tStage2uGMTEmulImdMuOMTFNegCompRatioClient.monitorDir = cms.untracked.string(ugmtEmuImdMuDqmDir+'/OMTF_neg/data_vs_emulator_comparison')
postProcessorRecoMuon = DQMEDHarvester("DQMGenericClient",
subDirs = cms.untracked.vstring("Muons/RecoMuonV/RecoMuon_MuonAssoc"),
#efficiencies and fractions
efficiency = cms.vstring("EffP 'Efficiency vs p' P SimP ",
"EffPt 'Efficiency vs p_{T}' Pt SimPt ",
"EffEta 'Efficiency vs #eta' Eta SimEta",
"EffPhi 'Efficiency vs #phi' Phi SimPhi",
"MisQProbPt 'Charge Mis-identification probability vs p_{T}' MisQPt SimPt ",
"MisQProbEta 'Charge Mis-identification probability vs #eta' MisQEta SimEta",
#fractions
"FractP 'Muontype fraction vs p' PMuon PMuonAll",
"FractPt 'Muontype fraction vs p_{T}' PtMuon PtMuonAll",
"FractEta 'Muontype fraction vs #eta' EtaMuon EtaMuonAll",
"FractPhi 'Muontype fraction vs #phi' PhiMuon PhiMuonAll",
),
resolution = cms.vstring("ErrP_vs_P '#sigma(p) vs p' ErrP_vs_P ",
"ErrP_vs_Eta '#sigma(p) vs #eta' ErrP_vs_Eta ",
"ErrPt_vs_Pt '#sigma(p_{T}) vs p_{T}' ErrPt_vs_Pt ",
"ErrPt_vs_Eta '#sigma(p_{T}) vs #eta' ErrPt_vs_Eta ",
"ErrEta_vs_Eta '#sigma(#eta) vs #eta ' ErrEta_vs_Eta ",
"ErrQPt_vs_Pt '#sigma(q/p_{T}) vs p_{T}' ErrQPt_vs_Pt ",
"ErrQPt_vs_Eta '#sigma(q/p_{T}) vs #eta' ErrQPt_vs_Eta ",
"PullEta_vs_Pt 'Pull of #eta vs p_{T}' PullEta_vs_Pt ",
"PullEta_vs_Eta 'Pull of #eta vs #eta' PullEta_vs_Eta",
"PullPhi_vs_Eta 'Pull of #phi vs #eta' PullPhi_vs_Eta",
"PullPt_vs_Pt 'Pull of p_{T} vs p_{T}' PullPt_vs_Pt ",
"PullPt_vs_Eta 'Pull of p_{T} vs #eta' PullPt_vs_Eta ",
),
outputFileName = cms.untracked.string("")
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
jetMETHLTOfflineClientAK4 = DQMEDHarvester("JetMETHLTOfflineClient",
processname = cms.string("HLT"),
DQMDirName=cms.string("HLT/JetMET"),
hltTag = cms.string("HLT")
)
jetMETHLTOfflineClientAK8 = jetMETHLTOfflineClientAK4.clone( DQMDirName = cms.string('HLT/JetMET/AK8'))
jetMETHLTOfflineClient = cms.Sequence( jetMETHLTOfflineClientAK4 * jetMETHLTOfflineClientAK8 )
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
EgammaPostVal = DQMEDHarvester(
"EmDQMPostProcessor",
subDir=cms.untracked.string("HLT/HLTEgammaValidation"),
dataSet=cms.untracked.string("unknown"),
noPhiPlots=cms.untracked.bool(True),
)
'rfio:/castor/cern.ch/cms/store/relval/2008/6/6/RelVal-RelValTTbar-1212531852-IDEAL_V1-2nd-02/0000/081018D5-EC33-DD11-A623-000423D6CA42.root'
))
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1))
process.MessageLogger = cms.Service(
"MessageLogger",
debugModules=cms.untracked.vstring(
'siPixelDigis', 'SiPixelRawDataErrorSource', 'SiPixelDigiSource',
'SiPixelClusterSource', 'SiPixelRecHitSource', 'sipixelEDAClient'),
cout=cms.untracked.PSet(threshold=cms.untracked.string('ERROR')),
destinations=cms.untracked.vstring('cout'))
process.AdaptorConfig = cms.Service("AdaptorConfig")
process.sipixelEDAClient = DQMEDHarvester(
"SiPixelEDAClient",
FileSaveFrequency=cms.untracked.int32(50),
StaticUpdateFrequency=cms.untracked.int32(10))
from DQMServices.Core.DQMQualityTester import DQMQualityTester
process.qTester = DQMQualityTester(
qtList=cms.untracked.FileInPath(
'DQM/SiPixelMonitorClient/test/sipixel_qualitytest_config.xml'),
QualityTestPrescaler=cms.untracked.int32(1),
getQualityTestsFromFile=cms.untracked.bool(True))
process.ModuleWebRegistry = cms.Service("ModuleWebRegistry")
process.Reco = cms.Sequence(process.siPixelDigis * process.siPixelClusters)
process.RAWmonitor = cms.Sequence(process.SiPixelRawDataErrorSource)
process.DIGImonitor = cms.Sequence(process.SiPixelDigiSource)
process.CLUmonitor = cms.Sequence(process.SiPixelClusterSource)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from DQM.EcalCommon.CommonParams_cfi import ecalCommonParams
from DQM.EcalMonitorClient.CertificationClient_cfi import ecalCertificationClient
ecalCertification = DQMEDHarvester(
"EcalDQMonitorClient",
moduleName=cms.untracked.string("Ecal Certification Client"),
# workers to be turned on
workers=cms.untracked.vstring("CertificationClient"),
# task parameters (included from indivitual cfis)
workerParameters=cms.untracked.PSet(
CertificationClient=ecalCertificationClient.clone()),
commonParameters=ecalCommonParams.clone(
willConvertToEDM=cms.untracked.bool(False)),
verbosity=cms.untracked.int32(0))
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
#define HltBTagPostValidation for the b-tag DQM validation (efficiency and mistagrate plot)
HltBTagPostValidation = DQMEDHarvester(
"HLTBTagHarvestingAnalyzer",
HLTPathNames=cms.vstring('HLT_PFMET120_',
'HLT_HT300PT30_QuadJet_75_60_45_40_v',
'HLT_PFHT380_SixJet32_DoubleBTagCSV_',
'HLT_Ele28_eta2p1_WPTight_Gsf_HT150_',
'HLT_IsoMu24_eta2p1_'),
histoName=cms.vstring(
'hltCombinedSecondaryVertexBJetTagsCalo',
'hltCombinedSecondaryVertexBJetTagsCalo',
'hltCombinedSecondaryVertexBJetTagsCalo',
'hltCombinedSecondaryVertexBJetTagsPF',
'hltCombinedSecondaryVertexBJetTagsPF',
),
minTag=cms.double(0.6),
# MC stuff
mcFlavours=cms.PSet(
light=cms.vuint32(1, 2, 3, 21), # udsg
c=cms.vuint32(4),
b=cms.vuint32(5),
g=cms.vuint32(21),
uds=cms.vuint32(1, 2, 3)))
#put all in a path
HltBTagPostVal = cms.Sequence(HltBTagPostValidation)
postProcessorTrack = DQMEDHarvester("DQMGenericClient",
subDirs = cms.untracked.vstring("Tracking/Track/*", "Tracking/TrackTPPtLess09/*", "Tracking/TrackFromPV/*", "Tracking/TrackFromPVAllTP/*", "Tracking/TrackAllTPEffic/*", "Tracking/TrackBuilding/*", "Tracking/TrackConversion/*", "Tracking/TrackGsf/*", "Tracking/TrackBHadron/*"),
efficiency = cms.vstring(
"effic 'Efficiency vs #eta' num_assoc(simToReco)_eta num_simul_eta",
"efficPt 'Efficiency vs p_{T}' num_assoc(simToReco)_pT num_simul_pT",
"effic_vs_hit 'Efficiency vs hit' num_assoc(simToReco)_hit num_simul_hit",
"effic_vs_layer 'Efficiency vs layer' num_assoc(simToReco)_layer num_simul_layer",
"effic_vs_pixellayer 'Efficiency vs pixel layer' num_assoc(simToReco)_pixellayer num_simul_pixellayer",
"effic_vs_3Dlayer 'Efficiency vs 3D layer' num_assoc(simToReco)_3Dlayer num_simul_3Dlayer",
"effic_vs_pu 'Efficiency vs pu' num_assoc(simToReco)_pu num_simul_pu",
"effic_vs_phi 'Efficiency vs #phi' num_assoc(simToReco)_phi num_simul_phi",
"effic_vs_dxy 'Efficiency vs Dxy' num_assoc(simToReco)_dxy num_simul_dxy",
"effic_vs_dz 'Efficiency vs Dz' num_assoc(simToReco)_dz num_simul_dz",
"effic_vs_dxypv 'Efficiency vs Dxy(PV)' num_assoc(simToReco)_dxypv num_simul_dxypv",
"effic_vs_dzpv 'Efficiency vs Dz(PV)' num_assoc(simToReco)_dzpv num_simul_dzpv",
"effic_vs_dxypv_zoomed 'Efficiency vs Dxy(PV)' num_assoc(simToReco)_dxypv_zoomed num_simul_dxypv_zoomed",
"effic_vs_dzpv_zoomed 'Efficiency vs Dz(PV)' num_assoc(simToReco)_dzpv_zoomed num_simul_dzpv_zoomed",
"duplicatesRate 'Duplicates Rate vs #eta' num_duplicate_eta num_reco_eta",
"duplicatesRate_Pt 'Duplicates Rate vs p_{T}' num_duplicate_pT num_reco_pT",
"duplicatesRate_hit 'Duplicates Rate vs hit' num_duplicate_hit num_reco_hit",
"duplicatesRate_layer 'Duplicates Rate vs layer' num_duplicate_layer num_reco_layer",
"duplicatesRate_pixellayer 'Duplicates Rate vs pixel layer' num_duplicate_pixellayer num_reco_pixellayer",
"duplicatesRate_3Dlayer 'Duplicates Rate vs layer' num_duplicate_3Dlayer num_reco_3Dlayer",
"duplicatesRate_pu 'Duplicates Rate vs pu' num_duplicate_pu num_reco_pu",
"duplicatesRate_phi 'Duplicates Rate vs #phi' num_duplicate_phi num_reco_phi",
"duplicatesRate_dxy 'Duplicates Rate vs Dxy' num_duplicate_dxy num_reco_dxy",
"duplicatesRate_dz 'Duplicates Rate vs Dz' num_duplicate_dz num_reco_dz",
"duplicatesRate_dxypv 'Duplicates Rate vs Dxy(PV)' num_duplicate_dxypv num_reco_dxypv",
"duplicatesRate_dzpv 'Duplicates Rate vs Dz(PV)' num_duplicate_dzpv num_reco_dzpv",
"duplicatesRate_dxypv_zoomed 'Duplicates Rate vs Dxy(PV)' num_duplicate_dxypv_zoomed num_reco_dxypv_zoomed",
"duplicatesRate_dzpv_zoomed 'Duplicates Rate vs Dz(PV)' num_duplicate_dzpv_zoomed num_reco_dzpv_zoomed",
"duplicatesRate_vertpos 'Duplicates Rate vs vertpos' num_duplicate_vertpos num_reco_vertpos",
"duplicatesRate_zpos 'Duplicates Rate vs zpos' num_duplicate_zpos num_reco_zpos",
"duplicatesRate_dr 'Duplicates Rate vs dr' num_duplicate_dr num_reco_dr",
"duplicatesRate_chi2 'Duplicates Rate vs normalized #chi^{2}' num_duplicate_chi2 num_reco_chi2",
"duplicatesRate_seedingLayerSet 'Duplicates rate vs. seedingLayerSet' num_duplicate_seedingLayerSet num_reco_seedingLayerSet",
"chargeMisIdRate 'Charge MisID Rate vs #eta' num_chargemisid_eta num_reco_eta",
"chargeMisIdRate_Pt 'Charge MisID Rate vs p_{T}' num_chargemisid_pT num_reco_pT",
"chargeMisIdRate_hit 'Charge MisID Rate vs hit' num_chargemisid_hit num_reco_hit",
"chargeMisIdRate_layer 'Charge MisID Rate vs layer' num_chargemisid_hit num_reco_layer",
"chargeMisIdRate_pixellayer 'Charge MisID Rate vs pixel layer' num_chargemisid_hit num_reco_pixellayer",
"chargeMisIdRate_3Dlayer 'Charge MisID Rate vs 3Dlayer' num_chargemisid_hit num_reco_3Dlayer",
"chargeMisIdRate_pu 'Charge MisID Rate vs pu' num_chargemisid_pu num_reco_pu",
"chargeMisIdRate_phi 'Charge MisID Rate vs #phi' num_chargemisid_phi num_reco_phi",
"chargeMisIdRate_dxy 'Charge MisID Rate vs Dxy' num_chargemisid_dxy num_reco_dxy",
"chargeMisIdRate_dz 'Charge MisID Rate vs Dz' num_chargemisid_versus_dz num_reco_dz",
"chargeMisIdRate_dxypv 'Charge MisID Rate vs Dxy(PV)' num_chargemisid_dxypv num_reco_dxypv",
"chargeMisIdRate_dzpv 'Charge MisID Rate vs Dz(PV)' num_chargemisid_versus_dzpv num_reco_dzpv",
"chargeMisIdRate_dxypv_zoomed 'Charge MisID Rate vs Dxy(PV)' num_chargemisid_dxypv_zoomed num_reco_dxypv_zoomed",
"chargeMisIdRate_dzpv_zoomed 'Charge MisID Rate vs Dz(PV)' num_chargemisid_versus_dzpv_zoomed num_reco_dzpv_zoomed",
"chargeMisIdRate_chi2 'Charge MisID Rate vs normalized #chi^{2}' num_chargemisid_chi2 num_reco_chi2",
"effic_vs_vertpos 'Efficiency vs vertpos' num_assoc(simToReco)_vertpos num_simul_vertpos",
"effic_vs_zpos 'Efficiency vs zpos' num_assoc(simToReco)_zpos num_simul_zpos",
"effic_vs_dr 'Efficiency vs dr' num_assoc(simToReco)_dr num_simul_dr",
"effic_vertcount_barrel 'efficiency in barrel vs N of pileup vertices' num_assoc(simToReco)_vertcount_barrel num_simul_vertcount_barrel",
"effic_vertcount_fwdpos 'efficiency in endcap(+) vs N of pileup vertices' num_assoc(simToReco)_vertcount_fwdpos num_simul_vertcount_fwdpos",
"effic_vertcount_fwdneg 'efficiency in endcap(-) vs N of pileup vertices' num_assoc(simToReco)_vertcount_fwdneg num_simul_vertcount_fwdneg",
"effic_vertz_barrel 'efficiency in barrel vs z of primary interaction vertex' num_assoc(simToReco)_vertz_barrel num_simul_vertz_barrel",
"effic_vertz_fwdpos 'efficiency in endcap(+) vs z of primary interaction vertex' num_assoc(simToReco)_vertz_fwdpos num_simul_vertz_fwdpos",
"effic_vertz_fwdneg 'efficiency in endcap(-) vs z of primary interaction vertex' num_assoc(simToReco)_vertz_fwdneg num_simul_vertz_fwdneg",
"pileuprate 'Pileup Rate vs #eta' num_pileup_eta num_reco_eta",
"pileuprate_Pt 'Pileup rate vs p_{T}' num_pileup_pT num_reco_pT",
"pileuprate_hit 'Pileup rate vs hit' num_pileup_hit num_reco_hit",
"pileuprate_layer 'Pileup rate vs layer' num_pileup_layer num_reco_layer",
"pileuprate_pixellayer 'Pileup rate vs layer' num_pileup_pixellayer num_reco_pixellayer",
"pileuprate_3Dlayer 'Pileup rate vs 3D layer' num_pileup_3Dlayer num_reco_3Dlayer",
"pileuprate_pu 'Pileup rate vs pu' num_pileup_pu num_reco_pu",
"pileuprate_phi 'Pileup rate vs #phi' num_pileup_phi num_reco_phi",
"pileuprate_dxy 'Pileup rate vs dxy' num_pileup_dxy num_reco_dxy",
"pileuprate_dz 'Pileup rate vs dz' num_pileup_dz num_reco_dz",
"pileuprate_dxypv 'Pileup rate vs dxy(PV)' num_pileup_dxypv num_reco_dxypv",
"pileuprate_dzpv 'Pileup rate vs dz(PV)' num_pileup_dzpv num_reco_dzpv",
"pileuprate_dxypv_zoomed 'Pileup rate vs dxy(PV)' num_pileup_dxypv_zoomed num_reco_dxypv_zoomed",
"pileuprate_dzpv_zoomed 'Pileup rate vs dz(PV)' num_pileup_dzpv_zoomed num_reco_dzpv_zoomed",
"pileuprate_vertpos 'Pileup rate vs vertpos' num_pileup_vertpos num_reco_vertpos",
"pileuprate_zpos 'Pileup rate vs zpos' num_pileup_zpos num_reco_zpos",
"pileuprate_dr 'Pileup rate vs dr' num_pileup_dr num_reco_dr",
"pileuprate_chi2 'Pileup rate vs normalized #chi^{2}' num_pileup_chi2 num_reco_chi2",
"pileuprate_seedingLayerSet 'Pileup rate vs. seedingLayerSet' num_pileup_seedingLayerSet num_reco_seedingLayerSet",
"fakerate 'Fake rate vs #eta' num_assoc(recoToSim)_eta num_reco_eta fake",
"fakeratePt 'Fake rate vs p_{T}' num_assoc(recoToSim)_pT num_reco_pT fake",
"fakerate_vs_hit 'Fake rate vs hit' num_assoc(recoToSim)_hit num_reco_hit fake",
"fakerate_vs_layer 'Fake rate vs layer' num_assoc(recoToSim)_layer num_reco_layer fake",
"fakerate_vs_pixellayer 'Fake rate vs layer' num_assoc(recoToSim)_pixellayer num_reco_pixellayer fake",
"fakerate_vs_3Dlayer 'Fake rate vs 3D layer' num_assoc(recoToSim)_3Dlayer num_reco_3Dlayer fake",
"fakerate_vs_pu 'Fake rate vs pu' num_assoc(recoToSim)_pu num_reco_pu fake",
"fakerate_vs_phi 'Fake rate vs phi' num_assoc(recoToSim)_phi num_reco_phi fake",
"fakerate_vs_dxy 'Fake rate vs dxy' num_assoc(recoToSim)_dxy num_reco_dxy fake",
"fakerate_vs_dz 'Fake rate vs dz' num_assoc(recoToSim)_dz num_reco_dz fake",
"fakerate_vs_dxypv 'Fake rate vs dxypv' num_assoc(recoToSim)_dxypv num_reco_dxypv fake",
"fakerate_vs_dzpv 'Fake rate vs dzpv' num_assoc(recoToSim)_dzpv num_reco_dzpv fake",
"fakerate_vs_dxypv_zoomed 'Fake rate vs dxypv' num_assoc(recoToSim)_dxypv_zoomed num_reco_dxypv_zoomed fake",
"fakerate_vs_dzpv_zoomed 'Fake rate vs dzpv' num_assoc(recoToSim)_dzpv_zoomed num_reco_dzpv_zoomed fake",
"fakerate_vs_vertpos 'Fake rate vs vertpos' num_assoc(recoToSim)_vertpos num_reco_vertpos fake",
"fakerate_vs_zpos 'Fake rate vs vertpos' num_assoc(recoToSim)_zpos num_reco_zpos fake",
"fakerate_vs_dr 'Fake rate vs dr' num_assoc(recoToSim)_dr num_reco_dr fake",
"fakerate_vs_chi2 'Fake rate vs normalized #chi^{2}' num_assoc(recoToSim)_chi2 num_reco_chi2 fake",
"fakerate_vs_seedingLayerSet 'Fake rate vs. seedingLayerSet' num_assoc(recoToSim)_seedingLayerSet num_reco_seedingLayerSet fake",
"fakerate_vertcount_barrel 'fake rate in barrel vs N of pileup vertices' num_assoc(recoToSim)_vertcount_barrel num_reco_vertcount_barrel fake",
"fakerate_vertcount_fwdpos 'fake rate in endcap(+) vs N of pileup vertices' num_assoc(recoToSim)_vertcount_fwdpos num_reco_vertcount_fwdpos fake",
"fakerate_vertcount_fwdneg 'fake rate in endcap(-) vs N of pileup vertices' num_assoc(recoToSim)_vertcount_fwdneg num_reco_vertcount_fwdneg fake"
"fakerate_ootpu_entire 'fake rate from out of time pileup vs N of pileup vertices' num_assoc(recoToSim)_ootpu_entire num_reco_ootpu_entire",
"fakerate_ootpu_barrel 'fake rate from out of time pileup in barrel vs N of pileup vertices' num_assoc(recoToSim)_ootpu_barrel num_reco_ootpu_barrel",
"fakerate_ootpu_fwdpos 'fake rate from out of time pileup in endcap(+) vs N of pileup vertices' num_assoc(recoToSim)_ootpu_fwdpos num_reco_ootpu_fwdpos",
"fakerate_ootpu_fwdneg 'fake rate from out of time pileup in endcap(-) vs N of pileup vertices' num_assoc(recoToSim)_ootpu_fwdneg num_reco_ootpu_fwdneg",
"effic_vs_dzpvcut 'Efficiency vs. dz (PV)' num_assoc(simToReco)_dzpvcut num_simul_dzpvcut",
"effic_vs_dzpvcut2 'Efficiency (tracking eff factorized out) vs. dz (PV)' num_assoc(simToReco)_dzpvcut num_simul2_dzpvcut",
"fakerate_vs_dzpvcut 'Fake rate vs. dz(PV)' num_assoc(recoToSim)_dzpvcut num_reco_dzpvcut fake",
"pileuprate_dzpvcut 'Pileup rate vs. dz(PV)' num_pileup_dzpvcut num_reco_dzpvcut",
"effic_vs_dzpvcut_pt 'Fraction of true p_{T} carried by recoed TPs from PV vs. dz(PV)' num_assoc(simToReco)_dzpvcut_pt num_simul_dzpvcut_pt",
"effic_vs_dzpvcut2_pt 'Fraction of true p_{T} carried by recoed TPs from PV (tracking eff factorized out) vs. dz(PV)' num_assoc(simToReco)_dzpvcut_pt num_simul2_dzpvcut_pt",
"fakerate_vs_dzpvcut_pt 'Fraction of fake p_{T} carried by tracks from PV vs. dz(PV)' num_assoc(recoToSim)_dzpvcut_pt num_reco_dzpvcut_pt fake",
"pileuprate_dzpvcut_pt 'Fraction of pileup p_{T} carried by tracks from PV vs. dz(PV)' num_pileup_dzpvcut_pt num_reco_dzpvcut_pt",
"effic_vs_dzpvsigcut 'Efficiency vs. dz(PV)/dzError' num_assoc(simToReco)_dzpvsigcut num_simul_dzpvsigcut",
"effic_vs_dzpvsigcut2 'Efficiency (tracking eff factorized out) vs. dz(PV)/dzError' num_assoc(simToReco)_dzpvsigcut num_simul2_dzpvsigcut",
"fakerate_vs_dzpvsigcut 'Fake rate vs. dz(PV)/dzError' num_assoc(recoToSim)_dzpvsigcut num_reco_dzpvsigcut fake",
"pileuprate_dzpvsigcut 'Pileup rate vs. dz(PV)/dzError' num_pileup_dzpvsigcut num_reco_dzpvsigcut",
"effic_vs_dzpvsigcut_pt 'Fraction of true p_{T} carried by recoed TPs from PV vs. dz(PV)/dzError' num_assoc(simToReco)_dzpvsigcut_pt num_simul_dzpvsigcut_pt",
"effic_vs_dzpvsigcut2_pt 'Fraction of true p_{T} carried by recoed TPs from PV (tracking eff factorized out) vs. dz(PV)/dzError' num_assoc(simToReco)_dzpvsigcut_pt num_simul2_dzpvsigcut_pt",
"fakerate_vs_dzpvsigcut_pt 'Fraction of fake p_{T} carried by tracks from PV vs. dz(PV)/dzError' num_assoc(recoToSim)_dzpvsigcut_pt num_reco_dzpvsigcut_pt fake",
"pileuprate_dzpvsigcut_pt 'Fraction of pileup p_{T} carried by tracks from PV vs. dz(PV)/dzError' num_pileup_dzpvsigcut_pt num_reco_dzpvsigcut_pt",
"effic_vs_simpvz 'Efficiency vs. sim PV z' num_assoc(simToReco)_simpvz num_simul_simpvz",
"fakerate_vs_simpvz 'Fake rate vs. sim PV z' num_assoc(recoToSim)_simpvz num_reco_simpvz fake",
"pileuprate_simpvz 'Pileup rate vs. sim PV z' num_pileup_simpvz num_reco_simpvz",
"fakerate_vs_mva1 'Fake rate vs. MVA1' num_assoc(recoToSim)_mva1 num_reco_mva1 fake",
"fakerate_vs_mva2 'Fake rate vs. MVA2' num_assoc(recoToSim)_mva2 num_reco_mva2 fake",
"fakerate_vs_mva3 'Fake rate vs. MVA3' num_assoc(recoToSim)_mva3 num_reco_mva3 fake",
"effic_vs_mva1cut 'Efficiency (tracking eff factorized out) vs. MVA1' num_assoc(simToReco)_mva1cut num_simul2_mva1cut",
"fakerate_vs_mva1cut 'Fake rate vs. MVA1' num_assoc(recoToSim)_mva1cut num_reco_mva1cut fake",
"effic_vs_mva2cut 'Efficiency (tracking eff factorized out) vs. MVA2' num_assoc(simToReco)_mva2cut num_simul2_mva2cut",
"effic_vs_mva2cut_hp 'Efficiency (tracking eff factorized out) vs. MVA2' num_assoc(simToReco)_mva2cut_hp num_simul2_mva2cut_hp",
"fakerate_vs_mva2cut 'Fake rate vs. MVA2' num_assoc(recoToSim)_mva2cut num_reco_mva2cut fake",
"fakerate_vs_mva2cut_hp 'Fake rate vs. MVA2' num_assoc(recoToSim)_mva2cut_hp num_reco_mva2cut_hp fake",
"effic_vs_mva3cut 'Efficiency (tracking eff factorized out) vs. MVA3' num_assoc(simToReco)_mva3cut num_simul2_mva3cut",
"effic_vs_mva3cut_hp 'Efficiency (tracking eff factorized out) vs. MVA3' num_assoc(simToReco)_mva3cut_hp num_simul2_mva3cut_hp",
"fakerate_vs_mva3cut 'Fake rate vs. MVA3' num_assoc(recoToSim)_mva3cut num_reco_mva3cut fake",
"fakerate_vs_mva3cut_hp 'Fake rate vs. MVA3' num_assoc(recoToSim)_mva3cut_hp num_reco_mva3cut_hp fake",
),
resolution = cms.vstring(
"cotThetares_vs_eta '#sigma(cot(#theta)) vs #eta' cotThetares_vs_eta",
"cotThetares_vs_pt '#sigma(cot(#theta)) vs p_{T}' cotThetares_vs_pt",
"h_dxypulleta 'd_{xy} Pull vs #eta' dxypull_vs_eta",
"dxyres_vs_eta '#sigma(d_{xy}) vs #eta' dxyres_vs_eta",
"dxyres_vs_pt '#sigma(d_{xy}) vs p_{T}' dxyres_vs_pt",
"h_dzpulleta 'd_{z} Pull vs #eta' dzpull_vs_eta",
"dzres_vs_eta '#sigma(d_{z}) vs #eta' dzres_vs_eta",
"dzres_vs_pt '#sigma(d_{z}) vs p_{T}' dzres_vs_pt",
"etares_vs_eta '#sigma(#eta) vs #eta' etares_vs_eta",
"h_phipulleta '#phi Pull vs #eta' phipull_vs_eta",
"h_phipullphi '#phi Pull vs #phi' phipull_vs_phi",
"phires_vs_eta '#sigma(#phi) vs #eta' phires_vs_eta",
"phires_vs_phi '#sigma(#phi) vs #phi' phires_vs_phi",
"phires_vs_pt '#sigma(#phi) vs p_{T}' phires_vs_pt",
"h_ptpulleta 'p_{T} Pull vs #eta' ptpull_vs_eta",
"h_ptpullphi 'p_{T} Pull vs #phi' ptpull_vs_phi",
"ptres_vs_eta '#sigma(p_{T}) vs #eta' ptres_vs_eta",
"ptres_vs_phi '#sigma(p_{T}) vs #phi' ptres_vs_phi",
"ptres_vs_pt '#sigma(p_{T}) vs p_{T}' ptres_vs_pt",
"h_thetapulleta '#theta Pull vs #eta' thetapull_vs_eta",
"h_thetapullphi '#theta Pull vs #phi' thetapull_vs_phi"
),
cumulativeDists = cms.untracked.vstring(
"num_reco_dzpvcut",
"num_assoc(recoToSim)_dzpvcut",
"num_assoc(simToReco)_dzpvcut",
"num_simul_dzpvcut",
"num_simul2_dzpvcut",
"num_pileup_dzpvcut",
"num_reco_dzpvcut_pt",
"num_assoc(recoToSim)_dzpvcut_pt",
"num_assoc(simToReco)_dzpvcut_pt",
"num_simul_dzpvcut_pt",
"num_simul2_dzpvcut_pt",
"num_pileup_dzpvcut_pt",
"num_reco_dzpvsigcut",
"num_assoc(recoToSim)_dzpvsigcut",
"num_assoc(simToReco)_dzpvsigcut",
"num_simul_dzpvsigcut",
"num_simul2_dzpvsigcut",
"num_pileup_dzpvsigcut",
"num_reco_dzpvsigcut_pt",
"num_assoc(recoToSim)_dzpvsigcut_pt",
"num_assoc(simToReco)_dzpvsigcut_pt",
"num_simul_dzpvsigcut_pt",
"num_simul2_dzpvsigcut_pt",
"num_pileup_dzpvsigcut_pt",
"num_reco_mva1cut descending",
"num_reco_mva2cut descending",
"num_reco_mva2cut_hp descending",
"num_reco_mva3cut descending",
"num_reco_mva3cut_hp descending",
"num_assoc(recoToSim)_mva1cut descending",
"num_assoc(recoToSim)_mva2cut descending",
"num_assoc(recoToSim)_mva2cut_hp descending",
"num_assoc(recoToSim)_mva3cut descending",
"num_assoc(recoToSim)_mva3cut_hp descending",
"num_assoc(simToReco)_mva1cut descending",
"num_assoc(simToReco)_mva2cut descending",
"num_assoc(simToReco)_mva2cut_hp descending",
"num_assoc(simToReco)_mva3cut descending",
"num_assoc(simToReco)_mva3cut_hp descending",
"num_simul2_mva1cut descending",
"num_simul2_mva2cut descending",
"num_simul2_mva2cut_hp descending",
"num_simul2_mva3cut descending",
"num_simul2_mva3cut_hp descending",
),
outputFileName = cms.untracked.string("")
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
TrackerMapFoldedClient = DQMEDHarvester(
"TrackFoldedOccupancyClient",
FolderName=cms.string('Tracking/TrackParameters'),
AlgoName=cms.string('GenTk'),
TrackQuality=cms.string('generalTracks'),
MeasurementState=cms.string('ImpactPoint'),
PhiMax=cms.double(3.141592654),
PhiMin=cms.double(-3.141592654),
EtaMax=cms.double(2.5),
EtaMin=cms.double(-2.5),
Eta2DBin=cms.int32(26),
Phi2DBin=cms.int32(32),
)
from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
phase1Pixel.toModify(TrackerMapFoldedClient, EtaMin=-3., EtaMax=3.)
from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
phase2_tracker.toModify(TrackerMapFoldedClient, EtaMin=-4.5, EtaMax=4.5)
TrackerMapFoldedClient_highpurity_dzPV0p1 = TrackerMapFoldedClient.clone(
TrackQuality=cms.string('highPurityTracks/dzPV0p1'))
TrackerMapFoldedClient_highpurity_pt0to1 = TrackerMapFoldedClient.clone(
TrackQuality=cms.string('highPurityTracks/pt_0to1'))
TrackerMapFoldedClient_highpurity_pt1 = TrackerMapFoldedClient.clone(
'met': ['efficiencyMET', 'efficiencyETMHF', 'efficiencyPFMetNoMu'],
'mht': ['efficiencyMHT'],
'ett': ['efficiencyETT'],
'htt': ['efficiencyHTT'],
}
from DQMOffline.L1Trigger.L1TCommon import generateEfficiencyStrings
efficiencyStrings = list(generateEfficiencyStrings(variables, plots))
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
l1tEtSumEfficiency = DQMEDHarvester(
"DQMGenericClient",
commands=cms.vstring(),
resolution=cms.vstring(),
subDirs=cms.untracked.vstring('L1T/L1TObjects/L1TEtSum/L1TriggerVsReco'),
efficiency=cms.vstring(),
efficiencyProfile=cms.untracked.vstring(efficiencyStrings),
)
l1tEtSumEmuEfficiency = l1tEtSumEfficiency.clone(
subDirs=cms.untracked.vstring(
'L1TEMU/L1TObjects/L1TEtSum/L1TriggerVsReco'),
)
# modifications for the pp reference run
variables_HI = variables
efficiencyStrings_HI = list(generateEfficiencyStrings(variables_HI, plots))
from Configuration.Eras.Modifier_ppRef_2017_cff import ppRef_2017
proc.TauValNumeratorAndDenominator = cms.Sequence(proc.RunHPSValidation)
"""
EFFICIENCY
Tau efficiency calculations
Define the Efficiency curves to produce. Each
efficiency producer takes the numberator and denominator
histograms and the dependent variables.
"""
plotPset = Utils.SetPlotSequence(proc.TauValNumeratorAndDenominator)
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
proc.efficiencies = DQMEDHarvester("TauDQMHistEffProducer", plots=plotPset)
################################################
#
# Normalizes All the histograms
#
################################################
proc.normalizePlots = cms.EDAnalyzer(
"DQMHistNormalizer",
plotNamesToNormalize=cms.vstring('*_pTRatio_*', '*_Size_*', '*_SumPt_*',
'*_dRTauRefJet*'),
reference=cms.string('*_pTRatio_allHadronic'))
proc.TauEfficiencies = cms.Sequence(proc.efficiencies * proc.normalizePlots)
"""
from DQM.L1TMonitor.L1TdeStage2uGMT_cff import ignoreBins
# directories
ugmtEmuDqmDir = "L1TEMU/L1TdeStage2uGT"
BX = 'CentralBX'
errHistNumStr = 'dataEmulSummary_' + BX
errHistDenStr = 'normalizationHisto'
ratioHistStr = 'dataEmulMismatchRatio_' + BX
l1tStage2uGTEmulatorCompRatioClientBX0 = DQMEDHarvester("L1TStage2RatioClient",
monitorDir = cms.untracked.string(ugmtEmuDqmDir),
inputNum = cms.untracked.string(ugmtEmuDqmDir+'/'+errHistNumStr),
inputDen = cms.untracked.string(ugmtEmuDqmDir+'/'+errHistDenStr),
ratioName = cms.untracked.string(ratioHistStr),
ratioTitle = cms.untracked.string('Summary of mismatch rates between uGT emulator and data'),
yAxisTitle = cms.untracked.string('# mismatch / # total'),
binomialErr = cms.untracked.bool(True)
)
l1tStage2uGTEmulatorCompRatioClientBXP1 = l1tStage2uGTEmulatorCompRatioClientBX0.clone()
l1tStage2uGTEmulatorCompRatioClientBXP2 = l1tStage2uGTEmulatorCompRatioClientBX0.clone()
l1tStage2uGTEmulatorCompRatioClientBXM1 = l1tStage2uGTEmulatorCompRatioClientBX0.clone()
l1tStage2uGTEmulatorCompRatioClientBXM2 = l1tStage2uGTEmulatorCompRatioClientBX0.clone()
BX = 'BX1'
errHistNumStr = 'dataEmulSummary_' + BX
errHistDenStr = 'normalizationHisto'
ratioHistStr = 'dataEmulMismatchRatio_' + BX
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
#
# This object is used to make changes for different running scenarios
#
#Client:
sipixelEDAClient = DQMEDHarvester(
"SiPixelEDAClient",
EventOffsetForInit=cms.untracked.int32(10),
ActionOnLumiSection=cms.untracked.bool(False),
ActionOnRunEnd=cms.untracked.bool(True),
HighResolutionOccupancy=cms.untracked.bool(False),
NoiseRateCutValue=cms.untracked.double(-1.),
NEventsForNoiseCalculation=cms.untracked.int32(100000),
UseOfflineXMLFile=cms.untracked.bool(True),
Tier0Flag=cms.untracked.bool(True),
DoHitEfficiency=cms.untracked.bool(True),
isUpgrade=cms.untracked.bool(False))
#QualityTester
from DQMServices.Core.DQMQualityTester import DQMQualityTester
sipixelQTester = DQMQualityTester(
qtList=cms.untracked.FileInPath(
'DQM/SiPixelMonitorClient/test/sipixel_tier0_qualitytest.xml'),
prescaleFactor=cms.untracked.int32(1),
getQualityTestsFromFile=cms.untracked.bool(True),
label=cms.untracked.string("SiPixelDQMQTests"),
verboseQT=cms.untracked.bool(False))
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from DQMOffline.Trigger.VBFSUSYMonitor_Client_cff import *
from DQMOffline.Trigger.LepHTMonitor_cff import *
from DQMOffline.Trigger.susyHLTEleCaloJetsClient_cfi import *
#george
double_soft_muon_muonpt_efficiency = DQMEDHarvester(
"DQMGenericClient",
subDirs=cms.untracked.vstring("HLT/SUSY/SOS/Muon/*"),
verbose=cms.untracked.uint32(0), # Set to 2 for all messages
resolution=cms.vstring(),
efficiency=cms.vstring(
"effic_muPt_1 'efficiency vs muon pt; muon pt [GeV]; efficiency' muPt_1_numerator muPt_1_variableBinning_denominator",
"effic_muEta_1 'efficiency vs muon eta; muon eta ; efficiency' muEta_1_variableBinning_numerator muEta_1_variableBinning_denominator",
"effic_muPhi_1 'efficiency vs muon phi; muon phi ; efficiency' muPhi_1_numerator muPhi_1_denominator",
"effic_muPt_2 'efficiency vs muon pt; muon pt [GeV]; efficiency' muPt_2_variableBinning_numerator muPt_2_variableBinning_denominator",
"effic_muEta_2 'efficiency vs muon eta; muon eta ; efficiency' muEta_2_variableBinning_numerator muEta_2_variableBinning_denominator",
"effic_muPhi_2 'efficiency vs muon phi; muon phi ; efficiency' muPhi_2_numerator muPhi_2_denominator",
"effic_mu1mu2Pt 'efficiency vs mu1mu2 Pt; mu1 Pt [GeV]; mu2 Pt [GeV]' mu1Pt_mu2Pt_numerator mu1Pt_mu2Pt_denominator",
"effic_mu1mu2Eta 'efficiency vs mu1mu2 Eta; mu1 Eta ; mu2 Eta' mu1Eta_mu2Eta_numerator mu1Eta_mu2Eta_denominator",
),
)
double_soft_muon_metpt_efficiency = DQMEDHarvester(
"DQMGenericClient",
subDirs=cms.untracked.vstring("HLT/SUSY/SOS/MET/*"),
verbose=cms.untracked.uint32(0), # Set to 2 for all messages
resolution=cms.vstring(),
efficiency=cms.vstring(
"effic_MET 'efficiency vs met pt; met [GeV]; efficiency' met_numerator met_denominator",
hltSiPixelPhase1ClustersNClusters,
hltSiPixelPhase1ClustersNClustersInclusive,
hltSiPixelPhase1ClustersEventrate, hltSiPixelPhase1ClustersPositionB,
hltSiPixelPhase1ClustersPositionF, hltSiPixelPhase1ClustersPositionXZ,
hltSiPixelPhase1ClustersPositionYZ, hltSiPixelPhase1ClustersSizeVsEta,
hltSiPixelPhase1ClustersReadoutCharge,
hltSiPixelPhase1ClustersReadoutNClusters,
hltSiPixelPhase1ClustersPixelToStripRatio)
## Uncomment to add trigger event flag settings
import DQM.SiPixelPhase1Common.TriggerEventFlag_cfi as triggerflag
hltSiPixelPhase1ClustersTriggers = cms.VPSet(
# triggerflag.genericTriggerEventFlag4HLTdb,
# triggerflag.genericTriggerEventFlag4L1bd,
)
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
hltSiPixelPhase1ClustersAnalyzer = DQMEDAnalyzer(
'SiPixelPhase1Clusters',
pixelSrc=cms.InputTag("hltSiPixelClusters"),
stripSrc=cms.InputTag("hltSiStripRawToClustersFacility"),
histograms=hltSiPixelPhase1ClustersConf,
geometry=hltSiPixelPhase1Geometry,
triggerflag=hltSiPixelPhase1ClustersTriggers,
)
hltSiPixelPhase1ClustersHarvester = DQMEDHarvester(
"SiPixelPhase1Harvester",
histograms=hltSiPixelPhase1ClustersConf,
geometry=hltSiPixelPhase1Geometry)
topEfficiency_elejets = DQMEDHarvester("DQMGenericClient",
subDirs = cms.untracked.vstring("HLT/TopHLTOffline/TopMonitor/EleJet/*"),
verbose = cms.untracked.uint32(0), # Set to 2 for all messages
resolution = cms.vstring(),
efficiency = cms.vstring(
"effic_metME 'efficiency vs MET; MET [GeV]; efficiency' metME_numerator metME_denominator",
"effic_elePt_1 'efficiency vs electron pt; electron pt [GeV]; efficiency' elePt_1_numerator elePt_1_denominator",
"effic_eleEta_1 'efficiency vs electron eta; electron eta ; efficiency' eleEta_1_numerator eleEta_1_denominator",
"effic_elePhi_1 'efficiency vs electron phi; electron phi ; efficiency' elePhi_1_numerator elePhi_1_denominator",
"effic_jetPt_1 'efficiency vs leading jet pt; jet pt [GeV]; efficiency' jetPt_1_numerator jetPt_1_denominator",
"effic_jetEta_1 'efficiency vs leading jet eta; jet eta ; efficiency' jetEta_1_numerator jetEta_1_denominator",
"effic_jetPhi_1 'efficiency vs leading jet phi; jet phi ; efficiency' jetPhi_1_numerator jetPhi_1_denominator",
"effic_eventHT 'efficiency vs event HT; event HT [GeV]; efficiency' eventHT_numerator eventHT_denominator",
"effic_jetEtaPhi_HEP17 'efficiency vs jet #eta-#phi; jet #eta; jet #phi' jetEtaPhi_HEP17_numerator jetEtaPhi_HEP17_denominator",
"effic_elePt_1_variableBinning 'efficiency vs electron pt; electron pt [GeV]; efficiency' elePt_1_variableBinning_numerator elePt_1_variableBinning_denominator",
"effic_eleEta_1_variableBinning 'efficiency vs electron eta; electron eta ; efficiency' eleEta_1_variableBinning_numerator eleEta_1_variableBinning_denominator",
"effic_jetPt_1_variableBinning 'efficiency vs leading jet pt; jet pt [GeV]; efficiency' jetPt_1_variableBinning_numerator jetPt_1_variableBinning_denominator",
"effic_jetEta_1_variableBinning 'efficiency vs leading jet eta; jet eta ; efficiency' jetEta_1_variableBinning_numerator jetEta_1_variableBinning_denominator",
"effic_eventHT_variableBinning 'efficiency vs event HT; event HT [GeV]; efficiency' eventHT_variableBinning_numerator eventHT_variableBinning_denominator",
"effic_jetMulti 'efficiency vs jet multiplicity; jet multiplicity; efficiency' jetMulti_numerator jetMulti_denominator",
"effic_eleMulti 'efficiency vs electron multiplicity; electron multiplicity; efficiency' eleMulti_numerator eleMulti_denominator",
"effic_muMulti 'efficiency vs muon multiplicity; muon multiplicity; efficiency' muMulti_numerator muMulti_denominator",
"effic_elePtEta_1 'efficiency vs electron pt-#eta; electron pt [GeV]; electron #eta' elePtEta_1_numerator elePtEta_1_denominator",
"effic_eleEtaPhi_1 'efficiency vs electron #eta-#phi; electron #eta ; electron #phi' eleEtaPhi_1_numerator eleEtaPhi_1_denominator",
"effic_jetPtEta_1 'efficiency vs jet pt-#eta; jet pt [GeV]; jet #eta' jetPtEta_1_numerator jetPtEta_1_denominator",
"effic_jetEtaPhi_1 'efficiency vs jet #eta-#phi; jet #eta ; jet #phi' jetEtaPhi_1_numerator jetEtaPhi_1_denominator",
"effic_elePt_jetPt 'efficiency vs electron pt - jet pt; electron pt [GeV] ; jet pt [GeV]' elePt_jetPt_numerator elePt_jetPt_denominator",
"effic_elePt_eventHT 'efficiency vs electron pt - event HT; electron pt [GeV] ; event HT [GeV]' elePt_eventHT_numerator elePt_eventHT_denominator",
),
)
# outputCommands = cms.untracked.vstring('drop *', 'keep *_MEtoEDMConverter_*_*'),
# fileName = cms.untracked.string("HcalValHarvestingEDM.root")
#)
process.hcalTowerAnalyzer = cms.EDAnalyzer(
"CaloTowersValidation",
outputFile=cms.untracked.string('CaloTowersValidationRelVal.root'),
CaloTowerCollectionLabel=cms.untracked.InputTag('towerMaker'),
hcalselector=cms.untracked.string('all'),
mc=cms.untracked.string('no'),
useAllHistos=cms.untracked.bool(False))
process.noiseRates = DQMEDHarvester(
'NoiseRates',
outputFile=cms.untracked.string('NoiseRatesRelVal.root'),
rbxCollName=cms.untracked.InputTag('hcalnoise'),
minRBXEnergy=cms.untracked.double(20.0),
minHitEnergy=cms.untracked.double(1.5),
useAllHistos=cms.untracked.bool(False))
process.hcalRecoAnalyzer = cms.EDAnalyzer(
"HcalRecHitsValidation",
outputFile=cms.untracked.string('HcalRecHitValidationRelVal.root'),
HBHERecHitCollectionLabel=cms.untracked.InputTag("hbhereco"),
HFRecHitCollectionLabel=cms.untracked.InputTag("hfreco"),
HORecHitCollectionLabel=cms.untracked.InputTag("horeco"),
eventype=cms.untracked.string('multi'),
ecalselector=cms.untracked.string('yes'),
hcalselector=cms.untracked.string('all'),
mc=cms.untracked.string('no'),
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
hep17Efficiency = DQMEDHarvester(
"DQMGenericClient",
subDirs=cms.untracked.vstring("HLT/EGM/HEP17/*"),
verbose=cms.untracked.uint32(0), # Set to 2 for all messages
resolution=cms.vstring(),
efficiency=cms.vstring(
"egamma_passFilter_et_ratioHEP17HEM17 'HEP17/HEM17;E_{T} [GeV];ratio' egamma_passFilter_et_hep17 egamma_passFilter_et_hem17",
"egamma_passFilter_etSC_ratioHEP17HEM17 'HEP17/HEM17;E_{T}^{SC} [GeV];ratio' egamma_passFilter_etSC_hep17 egamma_passFilter_etSC_hem17",
"egamma_passFilter_energy_ratioHEP17HEM17 'HEP17/HEM17;Energy [GeV];ratio' egamma_passFilter_energy_hep17 egamma_passFilter_energy_hem17",
"egamma_passFilter_phi_ratioHEP17HEM17 'HEP17/HEM17;#phi [rad];ratio' egamma_passFilter_phi_hep17 egamma_passFilter_phi_hem17",
"egamma_passFilter_hOverE_ratioHEP17HEM17 'HEP17/HEM17;H/E;ratio' egamma_passFilter_hOverE_hep17 egamma_passFilter_hOverE_hem17",
"egamma_passFilter_sigmaIEtaIEta_ratioHEP17HEM17 'HEP17/HEM17;#sigma_{i#etai#eta};ratio' egamma_passFilter_sigmaIEtaIEta_hep17 egamma_passFilter_sigmaIEtaIEta_hem17",
"egamma_passFilter_maxr9_ratioHEP17HEM17 'HEP17/HEM17;Max R9;ratio' egamma_passFilter_maxr9_hep17 egamma_passFilter_maxr9_hem17",
"egamma_passFilter_hltIsolEM_ratioHEP17HEM17 'HEP17/HEM17;HLT Iso EM [GeV];ratio' egamma_passFilter_hltIsolEM_hep17 egamma_passFilter_hltIsolEM_hem17",
"egamma_passFilter_hltIsolHad_ratioHEP17HEM17 'HEP17/HEM17;HLT Iso Had [GeV];ratio' egamma_passFilter_hltIsolHad_hep17 egamma_passFilter_hltIsolHad_hem17",
"egamma_passFilter_hltIsolTrksEle_ratioHEP17HEM17 'HEP17/HEM17;HLT Ele Iso Tracks [GeV];ratio' egamma_passFilter_hltIsolTrksEle_hep17 egamma_passFilter_hltIsolTrksEle_hem17",
"egamma_passFilter_HLTenergy_ratioHEP17HEM17 'HEP17/HEM17;HLT Energy [GeV];ratio' egamma_passFilter_HLTenergy_hep17 egamma_passFilter_HLTenergy_hem17",
"egamma_passFilter_HLTeta_ratioHEP17HEM17 'HEP17/HEM17;HLT #eta [rad];ratio' egamma_passFilter_HLTeta_hep17 egamma_passFilter_HLTeta_hem17",
"egamma_passFilter_HLTphi_ratioHEP17HEM17 'HEP17/HEM17;HLT #phi [rad];ratio' egamma_passFilter_HLTphi_hep17 egamma_passFilter_HLTphi_hem17",
),
efficiencyProfile=cms.untracked.vstring(),
)
trackingOfflineAnalyser = DQMEDHarvester(
"TrackingOfflineDQM",
GlobalStatusFilling=cms.untracked.int32(2),
UsedWithEDMtoMEConverter=cms.untracked.bool(True),
TopFolderName=cms.untracked.string("Tracking"),
TrackingGlobalQualityPSets=cms.VPSet(
cms.PSet(
QT=cms.string("Rate"),
dir=cms.string(
"TrackParameters/highPurityTracks/pt_1/GeneralProperties"),
name=cms.string("NumberOfTracks_"),
),
cms.PSet(
QT=cms.string("Chi2"),
dir=cms.string(
"TrackParameters/highPurityTracks/pt_1/GeneralProperties"),
name=cms.string("Chi2oNDF_"),
),
cms.PSet(
QT=cms.string("RecHits"),
dir=cms.string(
"TrackParameters/highPurityTracks/pt_1/HitProperties"),
name=cms.string("NumberOfRecHitsPerTrack_"),
),
cms.PSet(
QT=cms.string("Seed"),
dir=cms.string("TrackParameters/generalTracks/TrackBuilding"),
name=cms.string("NumberOfSeeds_"),
)),
TrackingLSQualityPSets=cms.VPSet(
cms.PSet(
QT=cms.string("Rate"),
LSdir=cms.string(
"TrackParameters/highPurityTracks/pt_1/GeneralProperties/LSanalysis"
),
LSname=cms.string("NumberOfTracks_lumiFlag_"),
LSlowerCut=cms.double(1.0),
LSupperCut=cms.double(1000.0)),
cms.PSet(
QT=cms.string("Chi2"),
LSdir=cms.string(
"TrackParameters/highPurityTracks/pt_1/GeneralProperties/LSanalysis"
),
LSname=cms.string("Chi2oNDF_lumiFlag_"),
LSlowerCut=cms.double(0.0),
LSupperCut=cms.double(25.0)),
cms.PSet(
QT=cms.string("RecHits"),
LSdir=cms.string(
"TrackParameters/highPurityTracks/pt_1/GeneralProperties/LSanalysis"
),
LSname=cms.string("NumberOfRecHitsPerTrack_lumiFlag_"),
LSlowerCut=cms.double(5.0),
LSupperCut=cms.double(20.0)),
cms.PSet(QT=cms.string("Seed"),
LSdir=cms.string("TrackParameters/generalTracks/LSanalysis"),
LSname=cms.string("NumberOfSeeds_lumiFlag_"),
LSlowerCut=cms.double(0.0),
LSupperCut=cms.double(1000000.0))))
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
l1tRpctfClient = DQMEDHarvester("L1TRPCTFClient",
input_dir = cms.untracked.string('L1T/L1TRPCTF'),
prescaleEvt = cms.untracked.int32(1),
verbose = cms.untracked.bool(False),
output_dir = cms.untracked.string('L1T/L1TRPCTF/Client'),
runInEventLoop=cms.untracked.bool(False),
runInEndLumi=cms.untracked.bool(True),
runInEndRun=cms.untracked.bool(True),
runInEndJob=cms.untracked.bool(False)
)
.save(),
Specification(PerLayer1D).groupBy("PXBarrel/Shell/PXLayer").save(),
Specification(PerLayer1D).groupBy("PXForward/HalfCylinder/PXRing/PXDisk").save()
)
)
SiPixelPhase1TrackResidualsResidualsY = SiPixelPhase1TrackResidualsResidualsX.clone(
name = "residual_y",
title = "Track Residuals Y",
xlabel = "(y_rec - y_pred) [cm]",
)
SiPixelPhase1TrackResidualsConf = cms.VPSet(
SiPixelPhase1TrackResidualsResidualsX,
SiPixelPhase1TrackResidualsResidualsY
)
SiPixelPhase1TrackResidualsAnalyzer = cms.EDAnalyzer("SiPixelPhase1TrackResiduals",
trajectoryInput = cms.string("generalTracks"),
Tracks = cms.InputTag("generalTracks"),
vertices = cms.InputTag("offlinePrimaryVertices"),
histograms = SiPixelPhase1TrackResidualsConf,
geometry = SiPixelPhase1Geometry
)
SiPixelPhase1TrackResidualsHarvester = DQMEDHarvester("SiPixelPhase1Harvester",
histograms = SiPixelPhase1TrackResidualsConf,
geometry = SiPixelPhase1Geometry
)
particleNetAK4BTagEfficiency = DQMEDHarvester(
"DQMGenericClient",
subDirs=cms.untracked.vstring(
"HLT/HIG/PNETAK4/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBTagParticleNet_2BTagSum0p65/"
),
verbose=cms.untracked.uint32(0), # Set to 2 for all messages
resolution=cms.vstring(),
efficiency=cms.vstring(
"eff_muon_pt 'Efficiency vs p_{T}(#mu); p_{T}(#mu); efficiency' muon_pt_numerator muon_pt_denominator",
"eff_muon_eta 'Efficiency vs #eta(#mu); #eta(#mu); efficiency' muon_eta_numerator muon_eta_denominator",
"eff_electron_pt 'Efficiency vs p_{T}(ele); p_{T}(ele); efficiency' electron_pt_numerator electron_pt_denominator",
"eff_electron_eta 'Efficiency vs #eta(ele); #eta(ele); efficiency' electron_eta_numerator electron_eta_denominator",
"eff_dilepton_pt 'Efficiency vs p_{T}(ll); p_{T}(ll); efficiency' dilepton_pt_numerator dilepton_pt_denominator",
"eff_dilepton_mass 'Efficiency vs m(ll); m(ll); efficiency' dilepton_mass_numerator dilepton_mass_denominator",
"eff_ht 'Efficiency vs H_{T}; H_{T}; efficiency' ht_numerator ht_denominator",
"eff_njets 'Efficiency vs N_{jets}; N_{jets}; efficiency' njets_numerator njets_denominator",
"eff_nbjets 'Efficiency vs N_{bjets}; N_{bjets}; efficiency' nbjets_numerator nbjets_denominator",
"eff_jet1_pt 'Efficiency vs p_{T}(j1); p_{T}(j1); efficiency' jet1_pt_numerator jet1_pt_denominator",
"eff_jet2_pt 'Efficiency vs p_{T}(j2); p_{T}(j2); efficiency' jet2_pt_numerator jet2_pt_denominator",
"eff_jet1_eta 'Efficiency vs #eta(j1); #eta(j1); efficiency' jet1_eta_numerator jet1_eta_denominator",
"eff_jet2_eta 'Efficiency vs #eta(j2); #eta(j2); efficiency' jet2_eta_numerator jet2_eta_denominator",
"eff_jet1_pnetscore 'Efficiency vs Lead PNET-score; Lead PNET-score; efficiency' jet1_pnetscore_numerator jet1_pnetscore_denominator",
"eff_jet2_pnetscore 'Efficiency vs Trail PNET-score; Trail PNET-score; efficiency' jet2_pnetscore_numerator jet2_pnetscore_denominator",
"eff_jet1_pnetscore_trans 'Efficiency vs Lead atanh(PNET-score); Lead atanh(PNET-score); efficiency' jet1_pnetscore_trans_numerator jet1_pnetscore_trans_denominator",
"eff_jet2_pnetscore_trans 'Efficiency vs Trail atanh(PNET-score); Trail atanh(PNET-score); efficiency' jet2_pnetscore_trans_numerator jet2_pnetscore_trans_denominator",
"eff_mean_2j_pnetscore 'Efficiency vs Mean(PNET-score); Mean(PNET-score); efficiency' mean_2j_pnetscore_numerator mean_2j_pnetscore_denominator",
"eff_mean_2j_pnetscore_trans 'Efficiency vs atanh(Mean(PNET-score)); atanh(Mean(PNET-score)); efficiency' mean_2j_pnetscore_trans_numerator mean_2j_pnetscore_trans_denominator",
"eff_jet1_pt_eta 'Efficiency vs j1 p_{T} and #eta; p_{T}(j1); #eta(j1); efficiency' jet1_pt_eta_numerator jet1_pt_eta_denominator",
"eff_jet2_pt_eta 'Efficiency vs j2 p_{T} and #eta; p_{T}(j2); #eta(j2); efficiency' jet2_pt_eta_numerator jet2_pt_eta_denominator",
"eff_jet1_pt_pnetscore1 'Efficiency vs j1 p_{T} and Lead PNET-score; p_{T}(j1); Lead PNET-score; efficiency' jet1_pt_pnetscore1_numerator jet1_pt_pnetscore1_denominator",
"eff_jet1_pt_pnetscore2 'Efficiency vs j1 p_{T} and Trail PNET-score; p_{T}(j1); Trail PNET-score; efficiency' jet1_pt_pnetscore2_numerator jet1_pt_pnetscore2_denominator",
"eff_jet1_pt_mean2pnetscore 'Efficiency vs j1 p_{T} and Mean(PNET-score); p_{T}(j1); Mean(PNET-score); efficiency' jet1_pt_mean2pnetscore_numerator jet1_pt_mean2pnetscore_denominator",
"eff_jet2_pt_pnetscore1 'Efficiency vs j2 p_{T} and Lead PNET-score; p_{T}(j2); Lead PNET-score; efficiency' jet2_pt_pnetscore1_numerator jet2_pt_pnetscore1_denominator",
"eff_jet2_pt_pnetscore2 'Efficiency vs j2 p_{T} and Trail PNET-score; p_{T}(j2); Trail PNET-score; efficiency' jet2_pt_pnetscore2_numerator jet2_pt_pnetscore2_denominator",
"eff_jet2_pt_mean2pnetscore 'Efficiency vs j2 p_{T} and Mean(PNET-score); p_{T}(j2); Mean(PNET-score); efficiency' jet2_pt_mean2pnetscore_numerator jet2_pt_mean2pnetscore_denominator",
"eff_jet1_pt_pnetscore1_trans 'Efficiency vs j1 p_{T} and Lead atanh(PNET-score); p_{T}(j1); Lead atanh(PNET-score); efficiency' jet1_pt_pnetscore1_trans_numerator jet1_pt_pnetscore1_trans_denominator",
"eff_jet1_pt_pnetscore2_trans 'Efficiency vs j1 p_{T} and Trail atanh(PNET-score); p_{T}(j1); Trail atanh(PNET-score); efficiency' jet1_pt_pnetscore2_trans_numerator jet1_pt_pnetscore2_trans_denominator",
"eff_jet1_pt_mean2pnetscore_trans 'Efficiency vs j1 p_{T} and atanh(Mean(PNET-score)); p_{T}(j1); atanh(Mean(PNET-score)); efficiency' jet1_pt_mean2pnetscore_trans_numerator jet1_pt_mean2pnetscore_trans_denominator",
"eff_jet2_pt_pnetscore1_trans 'Efficiency vs j2 p_{T} and Lead atanh(PNET-score); p_{T}(j2); Lead atanh(PNET-score); efficiency' jet2_pt_pnetscore1_trans_numerator jet2_pt_pnetscore1_trans_denominator",
"eff_jet2_pt_pnetscore2_trans 'Efficiency vs j2 p_{T} and Trail atanh(PNET-score); p_{T}(j2); Trail atanh(PNET-score); efficiency' jet2_pt_pnetscore2_trans_numerator jet2_pt_pnetscore2_trans_denominator",
"eff_jet2_pt_mean2pnetscore_trans 'Efficiency vs j2 p_{T} and atanh(Mean(PNET-score)); p_{T}(j2); atanh(Mean(PNET-score)); efficiency' jet2_pt_mean2pnetscore_trans_numerator jet2_pt_mean2pnetscore_trans_denominator",
))
SiPixelPhase1TrackClustersOnTrackChargeOuter,
SiPixelPhase1TrackClustersOnTrackChargeInner,
SiPixelPhase1TrackClustersOnTrackShapeOuter,
SiPixelPhase1TrackClustersOnTrackShapeInner,
SiPixelPhase1TrackClustersOnTrackSizeXOuter,
SiPixelPhase1TrackClustersOnTrackSizeXInner,
SiPixelPhase1TrackClustersOnTrackSizeXF,
SiPixelPhase1TrackClustersOnTrackSizeYOuter,
SiPixelPhase1TrackClustersOnTrackSizeYInner,
SiPixelPhase1TrackClustersOnTrackSizeYF,
SiPixelPhase1TrackClustersOnTrackSizeXYOuter,
SiPixelPhase1TrackClustersOnTrackSizeXYInner,
SiPixelPhase1TrackClustersOnTrackSizeXYF,
SiPixelPhase1ClustersChargeVsSizeOnTrack)
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
SiPixelPhase1TrackClustersAnalyzer = DQMEDAnalyzer(
'SiPixelPhase1TrackClusters',
clusters=cms.InputTag("siPixelClusters"),
clusterShapeCache=cms.InputTag("siPixelClusterShapeCache"),
tracks=cms.InputTag("generalTracks"),
vertices=cms.InputTag("offlinePrimaryVertices"),
histograms=SiPixelPhase1TrackClustersConf,
geometry=SiPixelPhase1Geometry,
triggerflags=trigger.SiPixelPhase1Triggers)
SiPixelPhase1TrackClustersHarvester = DQMEDHarvester(
"SiPixelPhase1Harvester",
histograms=SiPixelPhase1TrackClustersConf,
geometry=SiPixelPhase1Geometry)
hltProcess=cms.string('HLT'),
triggerPath=cms.string('HLT_Ele15_IsoVVVL_PFHT350'),
triggerPathAuxiliary=cms.string('HLT_Ele35_eta2p1_WP85_Gsf_v'),
triggerPathLeptonAuxiliary=cms.string(
'HLT_PFHT350_PFMET120_NoiseCleaned_v'),
csvlCut=cms.untracked.double(0.244),
csvmCut=cms.untracked.double(0.679),
csvtCut=cms.untracked.double(0.898),
jetPtCut=cms.untracked.double(30.0),
jetEtaCut=cms.untracked.double(3.0),
metCut=cms.untracked.double(250.0),
htCut=cms.untracked.double(450.0),
leptonPtThreshold=cms.untracked.double(25.0),
htThreshold=cms.untracked.double(450.0),
metThreshold=cms.untracked.double(-1.0),
csvThreshold=cms.untracked.double(-1.0))
SUSYoHLToEleHToControlSingleLeptonPOSTPROCESSING = DQMEDHarvester(
'DQMGenericClient',
subDirs=cms.untracked.vstring('HLT/SUSYBSM/HLT_Ele15_IsoVVVL_PFHT350'),
efficiency=cms.vstring(
"leptonTurnOn_eff ';Offline Electron p_{T} [GeV];#epsilon' leptonTurnOn_num leptonTurnOn_den",
"pfHTTurnOn_eff ';Offline PF H_{T} [GeV];#epsilon' pfHTTurnOn_num pfHTTurnOn_den"
),
resolution=cms.vstring(''))
# fastsim has no conversion collection (yet)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(SUSY_HLT_Ele_HT_Control_SingleLepton,
conversionCollection=cms.InputTag(''))
l1tStage2EmulatorEventInfoClient = DQMEDHarvester(
"L1TEventInfoClient",
monitorDir=cms.untracked.string("L1TEMU"),
# decide when to run and update the results of the quality tests
# retrieval of quality test results must be consistent with the event / LS / Run execution
#
runInEventLoop=cms.untracked.bool(False),
runInEndLumi=cms.untracked.bool(True),
runInEndRun=cms.untracked.bool(True),
runInEndJob=cms.untracked.bool(False),
#
# for each L1 system, give:
# - SystemLabel: system label
# - HwValLabel: system label as used in hardware validation package
# (the package producing the ErrorFlag histogram)
# - SystemDisable: system disabled: if 1, all quality tests for the system
# are disabled in the summary plot
# - for each quality test:
# - QualityTestName: name of quality test
# - QualityTestHist: histogram (full path)
# - QualityTestSummaryEnabled: 0 if disabled, 1 if enabled in summary plot
#
# the position in the parameter set gives, in reverse order, the position in the reportSummaryMap
# in the emulator column (left column)
L1Systems=cms.VPSet(
cms.PSet(SystemLabel=cms.string("ECAL_TPG"),
HwValLabel=cms.string("ETP"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(QualityTestName=cms.string(""),
QualityTestHist=cms.string(""),
QualityTestSummaryEnabled=cms.uint32(0)), )),
cms.PSet(SystemLabel=cms.string("HCAL_TPG"),
HwValLabel=cms.string("HTP"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(QualityTestName=cms.string(""),
QualityTestHist=cms.string(""),
QualityTestSummaryEnabled=cms.uint32(0)), )),
cms.PSet(SystemLabel=cms.string("Calo Layer1"),
HwValLabel=cms.string("Stage2CaloLayer1"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(QualityTestName=cms.string(""),
QualityTestHist=cms.string(""),
QualityTestSummaryEnabled=cms.uint32(0)), )),
cms.PSet(SystemLabel=cms.string("Calo Layer2"),
HwValLabel=cms.string("Stage2CaloLayer2"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(QualityTestName=cms.string(""),
QualityTestHist=cms.string(""),
QualityTestSummaryEnabled=cms.uint32(0)), )),
cms.PSet(
SystemLabel=cms.string("BMTF"),
HwValLabel=cms.string("Stage2BMTF"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("BMTFDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2BMTF/mismatchRatio"),
QualityTestSummaryEnabled=cms.uint32(1)), )),
cms.PSet(
SystemLabel=cms.string("OMTF"),
HwValLabel=cms.string("Stage2OMTF"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("OMTFDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2OMTF/mismatchRatio"),
QualityTestSummaryEnabled=cms.uint32(1)), )),
cms.PSet(
SystemLabel=cms.string("EMTF"),
HwValLabel=cms.string("Stage2EMTF"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("EMTFDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2EMTF/mismatchRatio"),
QualityTestSummaryEnabled=cms.uint32(1)), )),
cms.PSet(
SystemLabel=cms.string("uGMT"),
HwValLabel=cms.string("Stage2uGMT"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(
QualityTestName=cms.string("uGMTDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2uGMT/data_vs_emulator_comparison/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string(
"InterMuonsDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2uGMT/intermediate_muons/BMTF/data_vs_emulator_comparison/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string(
"InterMuonsDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2uGMT/intermediate_muons/OMTF_pos/data_vs_emulator_comparison/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string(
"InterMuonsDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2uGMT/intermediate_muons/OMTF_neg/data_vs_emulator_comparison/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string(
"InterMuonsDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2uGMT/intermediate_muons/EMTF_pos/data_vs_emulator_comparison/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
cms.PSet(
QualityTestName=cms.string(
"InterMuonsDE_MismatchRatioMax0p05"),
QualityTestHist=cms.string(
"L1TEMU/L1TdeStage2uGMT/intermediate_muons/EMTF_neg/data_vs_emulator_comparison/mismatchRatio"
),
QualityTestSummaryEnabled=cms.uint32(1)),
)),
cms.PSet(SystemLabel=cms.string("uGT"),
HwValLabel=cms.string("Stage2uGT"),
SystemDisable=cms.uint32(0),
QualityTests=cms.VPSet(
cms.PSet(QualityTestName=cms.string(""),
QualityTestHist=cms.string(""),
QualityTestSummaryEnabled=cms.uint32(0)), )),
),
#
# for each L1 trigger object, give:
# - ObjectLabel: object label as used in enum L1GtObject
# - ObjectDisable: emulator mask: if 1, the system is masked in the summary plot
#
# the position in the parameter set gives, in reverse order, the position in the reportSummaryMap
# in the trigger object column (right column)
L1Objects=cms.VPSet(),
#
# fast over-mask a system: if the name of the system is in the list, the system will be masked
# (the default mask value is given in L1Systems VPSet)
#
DisableL1Systems=cms.vstring(),
#
# fast over-mask an object: if the name of the object is in the list, the object will be masked
# (the default mask value is given in L1Objects VPSet)
#
DisableL1Objects=cms.vstring())
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
mssmHbbBtag = DQMEDHarvester("DQMGenericClient",
# subDirs = cms.untracked.vstring("HLT/Higgs/MssmHbb/semileptonic/BtagTrigger/pt40_noMuon/"),
subDirs = cms.untracked.vstring("HLT/HIG/MssmHbb/semileptonic/BtagTrigger/*"),
verbose = cms.untracked.uint32(0), # Set to 2 for all messages
resolution = cms.vstring(),
efficiency = cms.vstring(
"effic_BtagPT 'BTag rel eff vs pT; probe pT [GeV]; efficiency' pt_probe_match pt_probe",
"effic_BtagETA 'BTag rel eff vs eta; probe eta; efficiency' eta_probe_match eta_probe",
"effic_BtagPHI 'BTag rel eff vs phi; probe phi; efficiency' phi_probe_match phi_probe",
),
)
mssmHbbBtagSL40noMu = mssmHbbBtag.clone()
mssmHbbBtagSL40noMu.subDirs = cms.untracked.vstring("HLT/HIG/MssmHbb/semileptonic/BtagTrigger/pt40_noMuon")
mssmHbbBtagSL40 = mssmHbbBtag.clone()
#mssmHbbBtagSL40.subDirs = cms.untracked.vstring("HLT/Higgs/MssmHbb/semileptonic/BtagTrigger/pt40/")
mssmHbbBtagSL40.subDirs = cms.untracked.vstring("HLT/HIG/MssmHbb/semileptonic/BtagTrigger/pt40/")
mssmHbbBtagSL100 = mssmHbbBtag.clone()
#mssmHbbBtagSL100.subDirs = cms.untracked.vstring("HLT/Higgs/MssmHbb/semileptonic/BtagTrigger/pt100/")
mssmHbbBtagSL100.subDirs = cms.untracked.vstring("HLT/HIG/MssmHbb/semileptonic/BtagTrigger/pt100/")
mssmHbbBtagSL200 = mssmHbbBtag.clone()
#mssmHbbBtagSL200.subDirs = cms.untracked.vstring("HLT/Higgs/MssmHbb/semileptonic/BtagTrigger/pt200/")
mssmHbbBtagSL200.subDirs = cms.untracked.vstring("HLT/HIG/MssmHbb/semileptonic/BtagTrigger/pt200/")
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
################# Muon HLT Quality Tests #########################
qTesterMuonHLT = cms.EDAnalyzer(
"QualityTester",
qtList=cms.untracked.FileInPath(
'DQMOffline/Trigger/data/MuonHLT_QualityTests.xml'),
getQualityTestsFromFile=cms.untracked.bool(True),
prescaleFactor=cms.untracked.int32(1),
testInEventloop=cms.untracked.bool(False),
verboseQT=cms.untracked.bool(True),
qtestOnEndLumi=cms.untracked.bool(False),
qtestOnEndRun=cms.untracked.bool(True),
qtestOnEndJob=cms.untracked.bool(True),
#reportThreshold = cms.untracked.string("black")
)
muonHLTCertSummary = DQMEDHarvester(
"HLTMuonCertSummary",
verbose=cms.untracked.bool(False),
)
muonHLTCertSeq = cms.Sequence(qTesterMuonHLT * muonHLTCertSummary)
dataCertificationJetMET = DQMEDHarvester('DataCertificationJetMET',
fileName = cms.untracked.string(""),
refFileName = cms.untracked.string(""),
OutputFile = cms.untracked.bool(False),
OutputFileName = cms.untracked.string("DQMDataCertificationResult.root"),
Verbose = cms.untracked.int32(0),
metFolder = cms.untracked.string("Cleaned"),
jetAlgo = cms.untracked.string("ak4"),
folderName = cms.untracked.string("JetMET/EventInfo"),
METTypeRECO = cms.InputTag("pfMETT1"),
#for the uncleaned directory the flag needs to be set accordingly in
#metDQMConfig_cfi.py
METTypeRECOUncleaned = cms.InputTag("pfMet"),
METTypeMiniAOD = cms.InputTag("slimmedMETs"),
JetTypeRECO = cms.InputTag("ak4PFJetsCHS"),
JetTypeMiniAOD = cms.InputTag("slimmedJets"),
#if changed here, change METAnalyzer module in same manner and jetDQMconfig
etaBin = cms.int32(100),
etaMax = cms.double(5.0),
etaMin = cms.double(-5.0),
pVBin = cms.int32(100),
pVMax = cms.double(100.0),
pVMin = cms.double(0.0),
ptBin = cms.int32(100),
ptMax = cms.double(500.0),
ptMin = cms.double(20.0),
pfBarrelJetMeanTest = cms.untracked.bool(True),
pfBarrelJetKSTest = cms.untracked.bool(False),
pfEndcapJetMeanTest = cms.untracked.bool(True),
pfEndcapJetKSTest = cms.untracked.bool(False),
pfForwardJetMeanTest = cms.untracked.bool(True),
pfForwardJetKSTest = cms.untracked.bool(False),
caloJetMeanTest = cms.untracked.bool(True),
caloJetKSTest = cms.untracked.bool(False),
jptJetMeanTest = cms.untracked.bool(False),
jptJetKSTest = cms.untracked.bool(False),
caloMETMeanTest = cms.untracked.bool(True),
caloMETKSTest = cms.untracked.bool(False),
pfMETMeanTest = cms.untracked.bool(True),
pfMETKSTest = cms.untracked.bool(False),
tcMETMeanTest = cms.untracked.bool(False),
tcMETKSTest = cms.untracked.bool(False),
isHI = cms.untracked.bool(False),
)
MinJetPT=cms.double(20),
mcFlavours=cms.PSet(
light=cms.vuint32(1, 2, 3, 21), # udsg
c=cms.vuint32(4),
b=cms.vuint32(5),
g=cms.vuint32(21),
uds=cms.vuint32(1, 2, 3)),
mcPartons=cms.InputTag("hltBtagJetsbyValAlgo"))
#define bTagPostValidation for the b-tag DQM validation (efficiency and mistagrate plot)
process.bTagPostValidation = DQMEDHarvester(
"HLTBTagHarvestingAnalyzer",
HLTPathNames=fileini.btag_pathes,
histoName=fileini.btag_modules_string,
minTag=cms.double(0.6),
# MC stuff
mcFlavours=cms.PSet(
light=cms.vuint32(1, 2, 3, 21), # udsg
c=cms.vuint32(4),
b=cms.vuint32(5),
g=cms.vuint32(21),
uds=cms.vuint32(1, 2, 3)))
#read input file
process.source = cms.Source("PoolSource",
fileNames=cms.untracked.vstring(fileini.files))
#put all in a path
process.DQM_BTag = cms.Path(process.hltBtagTriggerSelection +
process.hltBtagJetMCTools +
process.VertexValidationVertices +
process.bTagValidation + process.bTagPostValidation
#+ process.EDMtoMEConverter
NEWpostProcessorRecoMuon = DQMEDHarvester("DQMGenericClient",
subDirs = cms.untracked.vstring("Muons/RecoMuonV/NewRecoMuon_MuonAssoc"),
#efficiencies and fractions
efficiency = cms.vstring("EffP 'Efficiency vs p' P SimP ",
"EffPt 'Efficiency vs p_{T}' Pt SimPt ",
"EffEta 'Efficiency vs #eta' Eta SimEta",
"EffPhi 'Efficiency vs #phi' Phi SimPhi",
"MisQProbPt 'Charge Mis-identification probability vs p_{T}' MisQPt SimPt ",
"MisQProbEta 'Charge Mis-identification probability vs #eta' MisQEta SimEta",
#fractions
"FractP 'Muontype fraction vs p' PMuon PMuonAll",
"FractPt 'Muontype fraction vs p_{T}' PtMuon PtMuonAll",
"FractEta 'Muontype fraction vs #eta' EtaMuon EtaMuonAll",
"FractPhi 'Muontype fraction vs #phi' PhiMuon PhiMuonAll",
),
resolution = cms.vstring("ErrP_vs_P '#sigma(p) vs p' ErrP_vs_P ",
"ErrP_vs_Eta '#sigma(p) vs #eta' ErrP_vs_Eta ",
"ErrPt_vs_Pt '#sigma(p_{T}) vs p_{T}' ErrPt_vs_Pt ",
"ErrPt_vs_Eta '#sigma(p_{T}) vs #eta' ErrPt_vs_Eta ",
"ErrEta_vs_Eta '#sigma(#eta) vs #eta ' ErrEta_vs_Eta ",
"ErrQPt_vs_Pt '#sigma(q/p_{T}) vs p_{T}' ErrQPt_vs_Pt ",
"ErrQPt_vs_Eta '#sigma(q/p_{T}) vs #eta' ErrQPt_vs_Eta ",
"PullEta_vs_Pt 'Pull of #eta vs p_{T}' PullEta_vs_Pt ",
"PullEta_vs_Eta 'Pull of #eta vs #eta' PullEta_vs_Eta",
"PullPhi_vs_Eta 'Pull of #phi vs #eta' PullPhi_vs_Eta",
"PullPt_vs_Pt 'Pull of p_{T} vs p_{T}' PullPt_vs_Pt ",
"PullPt_vs_Eta 'Pull of p_{T} vs #eta' PullPt_vs_Eta ",
),
outputFileName = cms.untracked.string("")
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
hcalsimhitsClient = DQMEDHarvester("HcalSimHitsClient",
DQMDirName = cms.string("/"), # root directory
Verbosity = cms.untracked.bool(False),
)
effName = effNameVar+"_"+etaString+"_"+qualStrings[ptQualCut[1]]
efficiencyStrings.append(effName+" '"+effName+";;L1 muon efficiency' "+effNumName+" "+effDenName)
else:
effDenName = effDenNameVar
effNumName = effNumNameVar+"_"+qualStrings[ptQualCut[1]]
effName = effNameVar+"_"+qualStrings[ptQualCut[1]]
efficiencyStrings.append(effName+" '"+effName+";;L1 muon efficiency' "+effNumName+" "+effDenName)
return efficiencyStrings
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from DQMOffline.L1Trigger.L1TMuonDQMOffline_cfi import ptQualCuts, ptQualCuts_HI
l1tMuonDQMEfficiency = DQMEDHarvester("DQMGenericClient",
subDirs = cms.untracked.vstring("L1T/L1TObjects/L1TMuon/L1TriggerVsReco/"),
efficiency = cms.vstring(),
efficiencyProfile = cms.untracked.vstring(generateEfficiencyStrings(ptQualCuts)),
resolution = cms.vstring(),
outputFileName = cms.untracked.string(""),
verbose = cms.untracked.uint32(0)
)
# emulator efficiency
l1tMuonDQMEmuEfficiency = l1tMuonDQMEfficiency.clone(
subDirs = cms.untracked.vstring("L1TEMU/L1TObjects/L1TMuon/L1TriggerVsReco/")
)
# modifications for the pp reference run
from Configuration.Eras.Modifier_ppRef_2017_cff import ppRef_2017
ppRef_2017.toModify(l1tMuonDQMEfficiency,
efficiencyProfile = cms.untracked.vstring(generateEfficiencyStrings(ptQualCuts_HI))
)
ppRef_2017.toModify(l1tMuonDQMEmuEfficiency,
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
rpcDcsInfoClient = DQMEDHarvester(
"RPCDcsInfoClient",
dcsInfoFolder=cms.untracked.string("RPC/DCSInfo"),
dqmProvInfoFolder=cms.untracked.string("Info/EventInfo"))
postProcessorRecoMuon = DQMEDHarvester("DQMGenericClient",
subDirs = cms.untracked.vstring("Muons/RecoMuonV/RecoMuon_MuonAssoc"),
#efficiencies and fractions
efficiency = cms.vstring("EffP 'Efficiency vs p' P SimP ",
"EffPt 'Efficiency vs p_{T}' Pt SimPt ",
"EffEta 'Efficiency vs #eta' Eta SimEta",
"EffPhi 'Efficiency vs #phi' Phi SimPhi",
"MisQProbPt 'Charge Mis-identification probability vs p_{T}' MisQPt SimPt ",
"MisQProbEta 'Charge Mis-identification probability vs #eta' MisQEta SimEta",
#fractions
"FractP 'Muontype fraction vs p' PMuon PMuonAll",
"FractPt 'Muontype fraction vs p_{T}' PtMuon PtMuonAll",
"FractEta 'Muontype fraction vs #eta' EtaMuon EtaMuonAll",
"FractPhi 'Muontype fraction vs #phi' PhiMuon PhiMuonAll",
),
resolution = cms.vstring("ErrP_vs_P '#sigma(p) vs p' ErrP_vs_P ",
"ErrP_vs_Eta '#sigma(p) vs #eta' ErrP_vs_Eta ",
"ErrPt_vs_Pt '#sigma(p_{T}) vs p_{T}' ErrPt_vs_Pt ",
"ErrPt_vs_Eta '#sigma(p_{T}) vs #eta' ErrPt_vs_Eta ",
"ErrEta_vs_Eta '#sigma(#eta) vs #eta ' ErrEta_vs_Eta ",
"ErrQPt_vs_Pt '#sigma(q/p_{T}) vs p_{T}' ErrQPt_vs_Pt ",
"ErrQPt_vs_Eta '#sigma(q/p_{T}) vs #eta' ErrQPt_vs_Eta ",
"PullEta_vs_Pt 'Pull of #eta vs p_{T}' PullEta_vs_Pt ",
"PullEta_vs_Eta 'Pull of #eta vs #eta' PullEta_vs_Eta",
"PullPhi_vs_Eta 'Pull of #phi vs #eta' PullPhi_vs_Eta",
"PullPt_vs_Pt 'Pull of p_{T} vs p_{T}' PullPt_vs_Pt ",
"PullPt_vs_Eta 'Pull of p_{T} vs #eta' PullPt_vs_Eta ",
),
outputFileName = cms.untracked.string("")
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from DQMServices.ClientConfig.genericClientPSetHelper_cff import *
rpcRecHitSimRecoClient = DQMEDHarvester(
"RPCRecHitValidClient",
subDir=cms.string("RPC/RPCRecHitV/SimVsReco"),
)
rpcRecHitPostValidation = DQMEDHarvester(
"DQMGenericClient",
subDirs=cms.untracked.vstring("RPC/RPCRecHitV/SimVsReco", ),
#subDirs = cms.untracked.vstring("RPC/RPCRecHitV/SimVsReco",
# "RPC/RPCRecHitV/SimVsDTExt",
# "RPC/RPCRecHitV/SimVsCSCExt"),
efficiency=cms.vstring(),
resolution=cms.vstring(),
efficiencyProfileSets=cms.untracked.VPSet(
efficSet("Efficiency/Effic_wheel",
"Barrel SimHit to RecHit matching efficiency;Wheel",
"Occupancy/MatchBarrelOccupancy_wheel",
"Occupancy/RefHitBarrelOccupancy_wheel"),
efficSet("Efficiency/Effic_station",
"Barrel SimHit to RecHit matching efficiency;Station",
"Occupancy/MatchBarrelOccupancy_station",
"Occupancy/RefHitBarrelOccupancy_station"),
efficSet("Efficiency/Effic_disk",
"Endcap SimHit to RecHit matching efficiency;Disk",
"Occupancy/MatchEndcapOccupancy_disk",
"Occupancy/RefHitEndcapOccupancy_disk"),
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
jetMETHLTOfflineClientAK4 = DQMEDHarvester("JetMETHLTOfflineClient",
processname = cms.string("HLT"),
DQMDirName=cms.string("HLT/JME/Jets/AK4"),
hltTag = cms.string("HLT")
)
jetMETHLTOfflineClientAK8 = jetMETHLTOfflineClientAK4.clone( DQMDirName = cms.string('HLT/JME/Jets/AK8'))
jetMETHLTOfflineClientAK4Fwd = jetMETHLTOfflineClientAK4.clone( DQMDirName = cms.string('HLT/JME/Jets/AK4Fwd'))
jetMETHLTOfflineClientAK8Fwd = jetMETHLTOfflineClientAK4.clone( DQMDirName = cms.string('HLT/JME/Jets/AK8Fwd'))
jetMETHLTOfflineClient = cms.Sequence( jetMETHLTOfflineClientAK4 * jetMETHLTOfflineClientAK8 * jetMETHLTOfflineClientAK4Fwd * jetMETHLTOfflineClientAK8Fwd)
NEWpostProcessorRecoMuon = DQMEDHarvester("DQMGenericClient",
subDirs = cms.untracked.vstring("Muons/RecoMuonV/NewRecoMuon_MuonAssoc"),
#efficiencies and fractions
efficiency = cms.vstring("EffP 'Efficiency vs p' P SimP ",
"EffPt 'Efficiency vs p_{T}' Pt SimPt ",
"EffEta 'Efficiency vs #eta' Eta SimEta",
"EffPhi 'Efficiency vs #phi' Phi SimPhi",
"MisQProbPt 'Charge Mis-identification probability vs p_{T}' MisQPt SimPt ",
"MisQProbEta 'Charge Mis-identification probability vs #eta' MisQEta SimEta",
#fractions
"FractP 'Muontype fraction vs p' PMuon PMuonAll",
"FractPt 'Muontype fraction vs p_{T}' PtMuon PtMuonAll",
"FractEta 'Muontype fraction vs #eta' EtaMuon EtaMuonAll",
"FractPhi 'Muontype fraction vs #phi' PhiMuon PhiMuonAll",
),
resolution = cms.vstring("ErrP_vs_P '#sigma(p) vs p' ErrP_vs_P ",
"ErrP_vs_Eta '#sigma(p) vs #eta' ErrP_vs_Eta ",
"ErrPt_vs_Pt '#sigma(p_{T}) vs p_{T}' ErrPt_vs_Pt ",
"ErrPt_vs_Eta '#sigma(p_{T}) vs #eta' ErrPt_vs_Eta ",
"ErrEta_vs_Eta '#sigma(#eta) vs #eta ' ErrEta_vs_Eta ",
"ErrQPt_vs_Pt '#sigma(q/p_{T}) vs p_{T}' ErrQPt_vs_Pt ",
"ErrQPt_vs_Eta '#sigma(q/p_{T}) vs #eta' ErrQPt_vs_Eta ",
"PullEta_vs_Pt 'Pull of #eta vs p_{T}' PullEta_vs_Pt ",
"PullEta_vs_Eta 'Pull of #eta vs #eta' PullEta_vs_Eta",
"PullPhi_vs_Eta 'Pull of #phi vs #eta' PullPhi_vs_Eta",
"PullPt_vs_Pt 'Pull of p_{T} vs p_{T}' PullPt_vs_Pt ",
"PullPt_vs_Eta 'Pull of p_{T} vs #eta' PullPt_vs_Eta ",
),
outputFileName = cms.untracked.string("")
)
