hltTauValIdealMonitorMC = DQMEDAnalyzer(
'HLTTauDQMOfflineSource',
HLTProcessName=cms.untracked.string(hltTauValidationProcess_IDEAL),
DQMBaseFolder=cms.untracked.string("HLT/TAU/RelVal/MC"),
TriggerResultsSrc=cms.untracked.InputTag("TriggerResults", "",
hltTauValidationProcess_IDEAL),
TriggerEventSrc=cms.untracked.InputTag("hltTriggerSummaryAOD", "",
hltTauValidationProcess_IDEAL),
L1Plotter=cms.untracked.PSet(
DQMFolder=cms.untracked.string('L1'),
L1Taus=cms.untracked.InputTag("caloStage2Digis", "Tau"),
L1ETM=cms.untracked.InputTag("caloStage2Digis", "EtSum"),
L1ETMMin=cms.untracked.double(50),
),
Paths=cms.untracked.string("PFTau"),
PathSummaryPlotter=cms.untracked.PSet(
DQMFolder=cms.untracked.string('Summary'), ),
Matching=cms.PSet(
doMatching=cms.untracked.bool(True),
matchFilters=cms.untracked.VPSet(
cms.untracked.PSet(
FilterName=cms.untracked.InputTag(
"TauMCProducer", "HadronicTauOneAndThreeProng"),
matchObjectID=cms.untracked.int32(15),
),
cms.untracked.PSet(
FilterName=cms.untracked.InputTag("TauMCProducer",
"LeptonicTauElectrons"),
matchObjectID=cms.untracked.int32(11),
),
cms.untracked.PSet(
FilterName=cms.untracked.InputTag("TauMCProducer",
"LeptonicTauMuons"),
matchObjectID=cms.untracked.int32(13),
),
cms.untracked.PSet(
FilterName=cms.untracked.InputTag("TauMCProducer", "MET"),
matchObjectID=cms.untracked.int32(0),
),
),
),
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
qie11Task = DQMEDAnalyzer(
"QIE11Task",
# standard
name=cms.untracked.string("QIE11Task"),
debug=cms.untracked.int32(0),
runkeyVal=cms.untracked.int32(0),
runkeyName=cms.untracked.string("pp_run"),
# tag
tagQIE11=cms.untracked.InputTag("hcalDigis"),
# cuts,
cut=cms.untracked.double(20),
ped=cms.untracked.int32(4),
# to be used exclusively
laserType=cms.untracked.int32(-1),
eventType=cms.untracked.int32(-1))
)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(1000)
)
process.FEVT = cms.OutputModule("PoolOutputModule",
outputCommands = cms.untracked.vstring('drop *', 'keep *_MEtoEDMConverter_*_*'),
fileName = cms.untracked.string("HcalValHarvestingEDM.root")
)
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
process.hcalDigiAnalyzer = DQMEDAnalyzer('HcalDigiTester',
digiLabel = cms.InputTag("hcalDigis"),
outputFile = cms.untracked.string('HcalDigisValidation_ZS.root'),
hcalselector = cms.untracked.string('noise'),
zside = cms.untracked.string('*')
)
process.hcalRecoAnalyzer = DQMEDAnalyzer('HcalRecHitsValidation',
outputFile = cms.untracked.string('HcalRecHitsValidation_ZS.root'),
HBHERecHitCollectionLabel = cms.untracked.InputTag("hbhereco"),
HFRecHitCollectionLabel = cms.untracked.InputTag("hfreco"),
HORecHitCollectionLabel = cms.untracked.InputTag("horeco"),
eventype = cms.untracked.string('single'),
mc = cms.untracked.string('yes'),
sign = cms.untracked.string('*'),
hcalselector = cms.untracked.string('noise'),
ecalselector = cms.untracked.string('no'),
)
threshold=cms.untracked.string('INFO'))))
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(100))
process.source = cms.Source("EmptySource",
numberEventsInRun=cms.untracked.uint32(1),
firstRun=cms.untracked.uint32(1))
process.poolDBESSource = cms.ESSource(
"PoolDBESSource",
BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'),
DBParameters=cms.PSet(
messageLevel=cms.untracked.int32(2),
authenticationPath=cms.untracked.string('/afs/cern.ch/cms/DB/conddb')),
timetype=cms.untracked.string('runnumber'),
connect=cms.string('sqlite_file:dbfile.db'),
toGet=cms.VPSet(
cms.PSet(record=cms.string('SiStripBadModuleRcd'),
tag=cms.string('SiStripBadModule_Fake_merged2'))))
process.load("CalibTracker.SiStripESProducers.SiStripQualityESProducer_cfi")
process.siStripQualityESProducer.ListOfRecordToMerge = cms.VPSet(
cms.PSet(record=cms.string("SiStripBadModuleRcd"), tag=cms.string("")))
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
process.reader = DQMEDAnalyzer("SiStripQualityStatistics",
dataLabel=cms.untracked.string(""),
TkMapFileName=cms.untracked.string(""))
process.p1 = cms.Path(process.reader)
l1tTauOfflineDQM = DQMEDAnalyzer(
"L1TTauOffline",
verbose = cms.untracked.bool(False),
muonInputTag = cms.untracked.InputTag("muons"),
tauInputTag = cms.untracked.InputTag("hpsPFTauProducer"),
metInputTag = cms.untracked.InputTag("pfMet"),
antiMuInputTag = cms.untracked.InputTag("hpsPFTauDiscriminationByTightMuonRejection3"),
antiEleInputTag = cms.untracked.InputTag("hpsPFTauDiscriminationByMVA6LooseElectronRejection"),
decayModeFindingInputTag = cms.untracked.InputTag("hpsPFTauDiscriminationByDecayModeFindingOldDMs"),
comb3TInputTag = cms.untracked.InputTag("hpsPFTauDiscriminationByTightCombinedIsolationDBSumPtCorr3Hits"),
l1tInputTag = cms.untracked.InputTag("caloStage2Digis:Tau"),
vtxInputTag = cms.untracked.InputTag("offlinePrimaryVertices"),
bsInputTag = cms.untracked.InputTag("offlineBeamSpot"),
triggerNames = cms.untracked.vstring("HLT_IsoMu18_v*","HLT_IsoMu20_v*","HLT_IsoMu22_v*","HLT_IsoMu24_v*","HLT_IsoMu27_v*"),
trigInputTag = cms.untracked.InputTag("hltTriggerSummaryAOD", "", "HLT"),
trigProcess = cms.untracked.string("HLT"),
trigProcess_token = cms.untracked.InputTag("TriggerResults","","HLT"),
histFolder=cms.string('L1T/L1TObjects/L1TTau/L1TriggerVsReco'),
tauEfficiencyThresholds=cms.vint32(tauEfficiencyThresholds),
tauEfficiencyBins=cms.vdouble(tauEfficiencyBins),
histDefinitions=cms.PSet(
nVertex=histDefinitions.nVertex.clone(),
ETvsET=histDefinitions.ETvsET.clone(),
PHIvsPHI=histDefinitions.PHIvsPHI.clone(),
),
)
# zero suppression DQM
l1tStage2uGMTZeroSupp = DQMEDAnalyzer(
"L1TMP7ZeroSupp",
fedIds = cms.vint32(1402),
rawData = cms.InputTag("rawDataCollector"),
# mask for inputs (pt==0 defines empty muon)
maskCapId1 = cms.untracked.vint32(0x000001FF,
0x00000000,
0x000001FF,
0x00000000,
0x000001FF,
0x00000000),
# mask for outputs (pt==0 defines empty muon)
maskCapId2 = cms.untracked.vint32(0x0007FC00,
0x00000000,
0x0007FC00,
0x00000000,
0x0007FC00,
0x00000000),
# mask for validation event outputs (pt==0 defines empty muon)
maskCapId3 = cms.untracked.vint32(0x0007FC00,
0x00000000,
0x0007FC00,
0x00000000,
0x0007FC00,
0x00000000),
# no masks defined for caption IDs 0 and 4-11
maxFEDReadoutSize = cms.untracked.int32(10000),
monitorDir = cms.untracked.string("L1T/L1TStage2uGMT/zeroSuppression/AllEvts"),
verbose = cms.untracked.bool(False),
)
print(process.PCCProd.PCCProducerParameters.modVeto)
#Make sure that variables match in producer.cc and .h
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
DQMStore = cms.Service("DQMStore")
process.load("DQMServices.Core.DQM_cfg")
#process.load('HLTrigger.Timer.FastTimerService_cff')
process.corrPCCProd = DQMEDAnalyzer(
"CorrPCCProducer",
CorrPCCProducerParameters=cms.PSet(
#Mod factor to count lumi and the string to specify output
inLumiObLabel=cms.string("PCCProd"),
ProdInst=cms.string("PCCRandom"),
approxLumiBlockSize=cms.int32(50),
trigstring=cms.untracked.string("corrPCCRand"),
type2_a=cms.double(0.00072),
type2_b=cms.double(0.014),
subSystemFolder=cms.untracked.string('AlCaReco')))
process.dqmEnvLumiPCC = DQMEDAnalyzer(
'DQMEventInfo', subSystemFolder=cms.untracked.string('AlCaRecoEventInfo'))
#Output for the Database
process.load("CondCore.CondDB.CondDB_cfi")
process.CondDB.connect = "sqlite_file:PCC_Corr.db"
process.PoolDBOutputService = cms.Service(
DQMOffline_Ele15_HT600 = DQMEDAnalyzer('LepHTMonitor',
electronCollection = cms.InputTag('gedGsfElectrons'),
electronVID = cms.InputTag("egmGsfElectronIDsForDQM:cutBasedElectronID-Summer16-80X-V1-medium"),
muonCollection = cms.InputTag(''),
muonIDlevel = cms.untracked.int32(2), ## 1: loose, 2: medium, 3: tight
pfMetCollection = cms.InputTag('pfMet'),
pfJetCollection = cms.InputTag('ak4PFJets'),
jetTagCollection = cms.InputTag(''),
vertexCollection = cms.InputTag('offlinePrimaryVertices'),
conversionCollection = cms.InputTag('conversions'),
beamSpot = cms.InputTag('offlineBeamSpot'),
folderName = cms.string('HLT_Ele15_IsoVVVL_PFHT600'),
jetPtCut = cms.untracked.double(30.0),
jetEtaCut = cms.untracked.double(2.5),
metCut = cms.untracked.double(-1.0),
htCut = cms.untracked.double(-1.0),
nels = cms.untracked.double(1),
nmus = cms.untracked.double(0),
leptonPtPlateau = cms.untracked.double(30.0), #defines plateau region for eta, phi distributions
leptonCountingThreshold = cms.untracked.double(10.0), # min lepton pT for lepton counting
lepIsoCut = cms.untracked.double(0.1), # max lepton reliso
lepEtaCut = cms.untracked.double(2.5), # max abs(eta)
lep_d0_cut_b = cms.untracked.double(0.0118), #barrel
lep_dz_cut_b = cms.untracked.double(0.373),
lep_d0_cut_e = cms.untracked.double(0.0739), #endcap
lep_dz_cut_e = cms.untracked.double(0.602),
ptbins = cms.vdouble(0,5,10,20,30,40,50,75,100,125,160,200,250),
htbins = cms.vdouble(0,50,100,150,200,250,300,350,400,450,500,600,750,1000,1500,2000),
nbins_eta = cms.untracked.int32(10),
nbins_phi = cms.untracked.int32(10),
nbins_npv = cms.untracked.int32(35),
etabins_min = cms.untracked.double(-2.5),
etabins_max = cms.untracked.double(2.5),
phibins_min = cms.untracked.double(-3.142),
phibins_max = cms.untracked.double(3.142),
npvbins_min = cms.untracked.double(0),
npvbins_max = cms.untracked.double(70),
numGenericTriggerEventPSet = cms.PSet(
andOr = cms.bool( False ),
andOrHlt = cms.bool(True),# True:=OR; False:=AND
hltInputTag = cms.InputTag( "TriggerResults::HLT" ),
hltPaths = cms.vstring("HLT_Ele15_IsoVVVL_PFHT600_v*"),
errorReplyHlt = cms.bool( False ),
verbosityLevel = cms.uint32(0)
),
den_lep_GenericTriggerEventPSet = cms.PSet(
andOr = cms.bool( False ),
andOrHlt = cms.bool(True),# True:=OR; False:=AND
hltInputTag = cms.InputTag( "TriggerResults::HLT" ),
hltPaths = cms.vstring("HLT_PFHT1050_v*"),
errorReplyHlt = cms.bool( False ),
dcsInputTag = cms.InputTag( "scalersRawToDigi" ),
dcsPartitions = cms.vint32 ( 24, 25, 26, 27, 28, 29 ), # 24-27: strip, 28-29: pixel, we should add all other detectors !
andOrDcs = cms.bool( False ),
errorReplyDcs = cms.bool( True ),
verbosityLevel = cms.uint32(0)
),
den_HT_GenericTriggerEventPSet = cms.PSet(
andOr = cms.bool( False ),
andOrHlt = cms.bool(True),# True:=OR; False:=AND
hltInputTag = cms.InputTag( "TriggerResults::HLT" ),
hltPaths = cms.vstring("HLT_Ele38_WPTight_Gsf_v*","HLT_Ele27_WPTight_Gsf_v*","HLT_Ele35_WPTight_Gsf_v*","HLT_Ele40_WPTight_Gsf_v*"),
errorReplyHlt = cms.bool( False ),
dcsInputTag = cms.InputTag( "scalersRawToDigi" ),
dcsPartitions = cms.vint32 ( 24, 25, 26, 27, 28, 29 ), # 24-27: strip, 28-29: pixel, we should add all other detectors !
andOrDcs = cms.bool( False ),
errorReplyDcs = cms.bool( True ),
verbosityLevel = cms.uint32(0)
),
)
dqmCSCClient = DQMEDAnalyzer('CSCMonitorModule',
BOOKING_XML_FILE = cms.FileInPath('DQM/CSCMonitorModule/data/emuDQMBooking.xml'),
InputObjects = cms.untracked.InputTag("rawDataCollector"),
PREBOOK_EFF_PARAMS = cms.untracked.bool(False),
EventProcessor = cms.untracked.PSet(
PROCESS_DDU = cms.untracked.bool(True),
PROCESS_CSC = cms.untracked.bool(True),
PROCESS_EFF_HISTOS = cms.untracked.bool(False),
PROCESS_EFF_PARAMETERS = cms.untracked.bool(False),
BINCHECKER_CRC_ALCT = cms.untracked.bool(True),
BINCHECKER_CRC_CLCT = cms.untracked.bool(True),
BINCHECKER_CRC_CFEB = cms.untracked.bool(True),
BINCHECKER_MODE_DDU = cms.untracked.bool(False),
BINCHECKER_OUTPUT = cms.untracked.bool(False),
FRAEFF_AUTO_UPDATE = cms.untracked.bool(False),
FRAEFF_SEPARATE_THREAD = cms.untracked.bool(False),
FOLDER_EMU = cms.untracked.string('CSC/Summary/'),
FOLDER_FED = cms.untracked.string('CSC/FED/'),
FOLDER_DDU = cms.untracked.string('CSC/DDU/'),
FOLDER_CSC = cms.untracked.string('CSC/CSC/'),
FOLDER_PAR = cms.untracked.string('CSC/EventInfo/reportSummaryContents/'),
DDU_CHECK_MASK = cms.untracked.uint32(0xFFFFDFFF),
DDU_BINCHECK_MASK = cms.untracked.uint32(0x16EBF7F6),
BINCHECK_MASK = cms.untracked.uint32(0x16EBF7F6),
FRAEFF_AUTO_UPDATE_START = cms.untracked.uint32(5),
FRAEFF_AUTO_UPDATE_FREQ = cms.untracked.uint32(200),
EFF_COLD_THRESHOLD = cms.untracked.double(0.1),
EFF_COLD_SIGFAIL = cms.untracked.double(2.0),
EFF_HOT_THRESHOLD = cms.untracked.double(2.0),
EFF_HOT_SIGFAIL = cms.untracked.double(5.0),
EFF_ERR_THRESHOLD = cms.untracked.double(0.1),
EFF_ERR_SIGFAIL = cms.untracked.double(5.0),
EFF_NODATA_THRESHOLD = cms.untracked.double(0.99),
EFF_NODATA_SIGFAIL = cms.untracked.double(5.0),
EVENTS_ECHO = cms.untracked.uint32(1000),
MO_FILTER = cms.untracked.vstring(
'+/^.*$/',
'-/All_Readout_Errors/',
'-/^DMB_.*$/',
'-/DDU_[0-9]+/',
'-/CSC_[0-9]+_[0-9]+/'
)
)
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
totemRPDQMSource = DQMEDAnalyzer(
'TotemRPDQMSource',
tagStatus=cms.InputTag("totemRPRawToDigi", "TrackingStrip"),
tagDigi=cms.untracked.InputTag("totemRPRawToDigi", "TrackingStrip"),
tagCluster=cms.untracked.InputTag("totemRPClusterProducer"),
tagRecHit=cms.untracked.InputTag("totemRPRecHitProducer"),
tagUVPattern=cms.untracked.InputTag("totemRPUVPatternFinder"),
tagLocalTrack=cms.untracked.InputTag("totemRPLocalTrackFitter"),
verbosity=cms.untracked.uint32(0),
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
l1trpctpg = DQMEDAnalyzer('L1TRPCTPG',
disableROOToutput=cms.untracked.bool(True),
rpctpgSource=cms.InputTag("rpcunpacker"),
rpctfSource=cms.InputTag("l1GtUnpack"),
verbose=cms.untracked.bool(False),
DQMStore=cms.untracked.bool(True))
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
tpComparisonTask = DQMEDAnalyzer(
"TPComparisonTask",
name=cms.untracked.string("TPComparisonTask"),
debug=cms.untracked.int32(0),
runkeyVal=cms.untracked.int32(0),
runkeyName=cms.untracked.string("pp_run"),
tag1=cms.untracked.InputTag("hcalDigis"),
tag2=cms.untracked.InputTag("uHBHEDigis"),
# tmp
_skip1x1=cms.untracked.bool(True))
process.qTester = DQMQualityTester(
qtList=cms.untracked.FileInPath(
'DQM/SiStripMonitorClient/data/sistrip_qualitytest_config.xml'),
prescaleFactor=cms.untracked.int32(1),
getQualityTestsFromFile=cms.untracked.bool(True))
#----------------------------
# DQM Playback Environment
#-----------------------------
process.load("DQM.Integration.test.environment_playback_cfi")
process.dqmEnv.subSystemFolder = "SiStrip"
process.dqmSaver.saveByMinute = 120
process.dqmSaver.dirName = cms.untracked.string(".")
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
process.dqmEnvTr = DQMEDAnalyzer(
'DQMEventInfo',
subSystemFolder=cms.untracked.string('Tracking'),
eventRateWindow=cms.untracked.double(0.5),
eventInfoFolder=cms.untracked.string('EventInfo'))
process.DQMCommon = cms.Sequence(process.qTester * process.dqmEnv *
process.dqmEnvTr * process.dqmSaver)
#----------------------------
# Scheduling
#-----------------------------
process.p = cms.Path(process.RecoForDQM_RealData_Cosmics * process.DQMCommon *
process.SiStripSources_Common *
process.SiStripSources_Cosmics * process.SiStripClients)
process.AdaptorConfig = cms.Service("AdaptorConfig")
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
SiPixelTrackResidualSource_Cosmics = DQMEDAnalyzer(
'SiPixelTrackResidualSource',
TopFolderName=cms.string('Pixel'),
src=cms.InputTag("siPixelTrackResiduals"),
clustersrc=cms.InputTag("siPixelClusters"),
tracksrc=cms.InputTag("ctfWithMaterialTracksP5"),
debug=cms.untracked.bool(False),
saveFile=cms.untracked.bool(False),
outputFile=cms.string('Pixel_DQM_TrackResidual.root'),
# (SK) keep rstracks commented out in case of resurrection
# TrackCandidateProducer = cms.string('rsTrackCandidatesP5'),
TrackCandidateProducer=cms.string('ckfTrackCandidatesP5'),
TrackCandidateLabel=cms.string(''),
TTRHBuilder=cms.string('WithTrackAngle'),
Fitter=cms.string('KFFittingSmootherWithOutliersRejectionAndRK'),
modOn=cms.untracked.bool(False),
reducedSet=cms.untracked.bool(True),
ladOn=cms.untracked.bool(True),
layOn=cms.untracked.bool(True),
phiOn=cms.untracked.bool(True),
ringOn=cms.untracked.bool(True),
bladeOn=cms.untracked.bool(True),
diskOn=cms.untracked.bool(True),
PtMinRes=cms.untracked.double(4.0),
digisrc=cms.InputTag("siPixelDigis"),
# (SK) keep rstracks commented out in case of resurrection
# trajectoryInput = cms.InputTag('rsWithMaterialTracksP5')
trajectoryInput=cms.InputTag('ctfWithMaterialTracksP5'))
dqmBeamMonitor = DQMEDAnalyzer("BeamMonitor",
monitorName = cms.untracked.string('BeamMonitor'),
beamSpot = cms.untracked.InputTag('offlineBeamSpot'), ## hltOfflineBeamSpot for HLTMON
primaryVertex = cms.untracked.InputTag('offlinePrimaryVertices'),
timeInterval = cms.untracked.int32(920),
fitEveryNLumi = cms.untracked.int32(1),
resetEveryNLumi = cms.untracked.int32(20),
fitPVEveryNLumi = cms.untracked.int32(1),
resetPVEveryNLumi = cms.untracked.int32(5),
Debug = cms.untracked.bool(False),
OnlineMode = cms.untracked.bool(True),
recordName = cms.untracked.string('BeamSpotOnlineHLTObjectsRcd'),
useLockRecords = cms.untracked.bool(False),
BeamFitter = cms.PSet(
Debug = cms.untracked.bool(False),
TrackCollection = cms.untracked.InputTag('generalTracks'),
IsMuonCollection = cms.untracked.bool(False),
WriteAscii = cms.untracked.bool(False),
AsciiFileName = cms.untracked.string('BeamFit.txt'), ## all results
AppendRunToFileName = cms.untracked.bool(True), #runnumber will be inserted to the file name
WriteDIPAscii = cms.untracked.bool(False),
DIPFileName = cms.untracked.string('BeamFitDIP.txt'),
SaveNtuple = cms.untracked.bool(False),
SavePVVertices = cms.untracked.bool(False),
SaveFitResults = cms.untracked.bool(False),
OutputFileName = cms.untracked.string('BeamFit.root'), ## ntuple filename
MinimumPt = cms.untracked.double(1.0),
MaximumEta = cms.untracked.double(2.4),
MaximumImpactParameter = cms.untracked.double(1.0),
MaximumZ = cms.untracked.double(60),
MinimumTotalLayers = cms.untracked.int32(6),
MinimumPixelLayers = cms.untracked.int32(0),
MaximumNormChi2 = cms.untracked.double(10.0),
TrackAlgorithm = cms.untracked.vstring(), ## ctf,rs,cosmics,initialStep,lowPtTripletStep...; for all algos, leave it blank
TrackQuality = cms.untracked.vstring(), ## loose, tight, highPurity...; for all qualities, leave it blank
InputBeamWidth = cms.untracked.double(0.0060), ## beam width used for Trk fitter, used only when result from PV is not available
FractionOfFittedTrks = cms.untracked.double(0.9),
MinimumInputTracks = cms.untracked.int32(150),
deltaSignificanceCut = cms.untracked.double(10)
),
PVFitter = cms.PSet(
Debug = cms.untracked.bool(False),
Apply3DFit = cms.untracked.bool(True),
VertexCollection = cms.untracked.InputTag('offlinePrimaryVertices'),
#WriteAscii = cms.untracked.bool(True),
#AsciiFileName = cms.untracked.string('PVFit.txt'),
maxNrStoredVertices = cms.untracked.uint32(100000),
minNrVerticesForFit = cms.untracked.uint32(50),
minVertexNdf = cms.untracked.double(10.),
maxVertexNormChi2 = cms.untracked.double(10.),
minVertexNTracks = cms.untracked.uint32(0),
minVertexMeanWeight = cms.untracked.double(0.5),
maxVertexR = cms.untracked.double(2),
maxVertexZ = cms.untracked.double(10),
errorScale = cms.untracked.double(0.9),
nSigmaCut = cms.untracked.double(50.),
FitPerBunchCrossing = cms.untracked.bool(False),
useOnlyFirstPV = cms.untracked.bool(False),
minSumPt = cms.untracked.double(0.)
),
dxBin = cms.int32(200),
dxMin = cms.double(-1.0),
dxMax = cms.double(1.0),
vxBin = cms.int32(200),
vxMin = cms.double(-0.5),
vxMax = cms.double(0.5),
dzBin = cms.int32(80),
dzMin = cms.double(-20),
dzMax = cms.double(20),
phiBin = cms.int32(63),
phiMin = cms.double(-3.15),
phiMax = cms.double(3.15)
)
jetMETHLTOfflineSourceAK4 = DQMEDAnalyzer(
"JetMETHLTOfflineSource",
dirname = cms.untracked.string("HLT/JME/Jets/AK4"),
#
processname = cms.string("HLT"),
triggerSummaryLabel = cms.InputTag("hltTriggerSummaryAOD","","HLT"),
triggerResultsLabel = cms.InputTag("TriggerResults","","HLT"),
pathnameMuon = cms.untracked.vstring("HLT_IsoMu24_IterTrk02_v"),
pathnameMB = cms.untracked.vstring("HLT_Physics_v"),
#
verbose = cms.untracked.bool(False),
runStandalone = cms.untracked.bool(False),
#
plotAll = cms.untracked.bool(True),
plotEff = cms.untracked.bool(True),
nameForEff = cms.untracked.bool(True),
#
CaloMETCollectionLabel = cms.InputTag("caloMet"),
PFMETCollectionLabel = cms.InputTag("pfMet"),
#Use on-the-fly correction
CaloJetCollectionLabel = cms.InputTag("ak4CaloJets"),
PFJetCollectionLabel = cms.InputTag("ak4PFJets"),
CaloJetCorLabel = cms.InputTag("ak4CaloL1FastL2L3ResidualCorrector"), #dummy residual corrections now also provided for MC GTs
PFJetCorLabel = cms.InputTag("ak4PFL1FastL2L3ResidualCorrector"), #dummy residual corrections now also provided for MC GTs
#
fEMF = cms.untracked.double(0.01),
feta = cms.untracked.double(2.6),
fHPD = cms.untracked.double(0.98),
n90Hits = cms.untracked.double(1),
minNHEF = cms.untracked.double(0.),
maxNHEF = cms.untracked.double(1.),
minCHEF = cms.untracked.double(0.),
maxCHEF = cms.untracked.double(1.),
minNEMF = cms.untracked.double(0.),
maxNEMF = cms.untracked.double(1.),
minCEMF = cms.untracked.double(0.),
maxCEMF = cms.untracked.double(1.),
#
pathFilter = cms.untracked.vstring("HLT_CaloJet",
"HLT_PFJet",
"HLT_PFNoPUJet",
"HLT_DiPFJetAve",
"HLT_DiCaloJetAve",
"HLT_PFMET",
"HLT_PFchMET",
"HLT_MET",
"HLT_CaloMET"),
pathRejectKeyword = cms.untracked.vstring("dEdx","NoBPTX"),
#
pathPairs = cms.VPSet(
cms.PSet(
pathname = cms.string("HLT_PFJet60_v"),
denompathname = cms.string("HLT_PFJet40_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet80_v"),
denompathname = cms.string("HLT_PFJet60_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet140_v"),
denompathname = cms.string("HLT_PFJet80_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet200_v"),
denompathname = cms.string("HLT_PFJet140_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet260_v"),
denompathname = cms.string("HLT_PFJet200_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet320_v"),
denompathname = cms.string("HLT_PFJet260_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet400_v"),
denompathname = cms.string("HLT_PFJet320_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet450_v"),
denompathname = cms.string("HLT_PFJet400_v"),
),
cms.PSet(
pathname = cms.string("HLT_PFJet500_v"),
denompathname = cms.string("HLT_PFJet450_v"),
)
),
#
JetIDParams = cms.PSet(
useRecHits = cms.bool(True),
hbheRecHitsColl = cms.InputTag("hbhereco"),
hoRecHitsColl = cms.InputTag("horeco"),
hfRecHitsColl = cms.InputTag("hfreco"),
ebRecHitsColl = cms.InputTag("ecalRecHit", "EcalRecHitsEB"),
eeRecHitsColl = cms.InputTag("ecalRecHit", "EcalRecHitsEE")
)
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
SUSY_HLT_CaloHT200 = DQMEDAnalyzer(
'SUSY_HLT_InclusiveHT',
trigSummary=cms.InputTag("hltTriggerSummaryAOD"),
pfMETCollection=cms.InputTag("pfMet"),
pfJetCollection=cms.InputTag("ak4PFJetsCHS"),
caloJetCollection=cms.InputTag("ak4CaloJets"),
TriggerResults=cms.InputTag('TriggerResults', '', 'HLT'),
TriggerPath=cms.string('HLT_HT200_v'),
TriggerPathAuxiliaryForHadronic=cms.string(
'HLT_IsoMu24_eta2p1_IterTrk02_v'),
TriggerFilter=cms.InputTag('hltHT200', '',
'HLT'), #the last filter in the path
PtThrJet=cms.untracked.double(40.0),
EtaThrJet=cms.untracked.double(3.0))
SUSY_HLT_CaloHT250 = DQMEDAnalyzer(
'SUSY_HLT_InclusiveHT',
trigSummary=cms.InputTag("hltTriggerSummaryAOD"),
pfMETCollection=cms.InputTag("pfMet"),
pfJetCollection=cms.InputTag("ak4PFJetsCHS"),
caloJetCollection=cms.InputTag("ak4CaloJets"),
TriggerResults=cms.InputTag('TriggerResults', '', 'HLT'),
TriggerPath=cms.string('HLT_HT250_v'),
TriggerPathAuxiliaryForHadronic=cms.string(
'HLT_IsoMu24_eta2p1_IterTrk02_v'),
TriggerFilter=cms.InputTag('hltHT250', '',
'HLT'), #the last filter in the path
from DQM.L1TMonitor.L1TStage2BMTF_cfi import *
# zero suppression DQM
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
l1tStage2BmtfZeroSupp = DQMEDAnalyzer(
"L1TMP7ZeroSupp",
fedIds = cms.vint32(1376, 1377),
rawData = cms.InputTag("rawDataCollector"),
# mask for inputs (pt==0 defines empty muon)
maskCapId1 = cms.untracked.vint32(0x01c00000,
0x01c00000,
0x01c00000,
0x01c00000,
0x00200000,
0x00000000),
# mask for outputs (pt==0 defines empty muon)
maskCapId2 = cms.untracked.vint32(0x000001FF,
0x00000000,
0x000001FF,
0x00000000,
0x000001FF,
0x00000000),
# no masks defined for caption IDs 0 and 3-11
maxFEDReadoutSize = cms.untracked.int32(7000),
monitorDir = cms.untracked.string("L1T/L1TStage2BMTF/zeroSuppression/AllEvts"),
verbose = cms.untracked.bool(False),
)
# ZS of validation events (to be used after fat event filter)
l1tStage2BmtfZeroSuppFatEvts = l1tStage2BmtfZeroSupp.clone()
l1tStage2BmtfZeroSuppFatEvts.monitorDir = cms.untracked.string("L1T/L1TStage2BMTF/zeroSuppression/FatEvts")
from Validation.RecoTau.dataTypes.ValidateTausOnRealElectronsData_cff import *
from Validation.RecoTau.dataTypes.ValidateTausOnRealData_cff import *
from Validation.RecoTau.dataTypes.ValidateTausOnRealMuonsData_cff import *
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
dqmInfoTauV = DQMEDAnalyzer("DQMEventInfo",
subSystemFolder=cms.untracked.string('RecoTauV'))
produceDenoms = cms.Sequence(produceDenominatorRealData +
produceDenominatorRealElectronsData +
produceDenominatorRealMuonsData)
seqModifier = ApplyFunctionToSequence(lambda module: setTrigger(
module,
cms.PSet(hltDBKey=cms.string('TauTriggerForALLQCDDataset'),
hltPaths=cms.vstring('HLT_IsoMu24_eta2p1_v*'))))
TauValNumeratorAndDenominatorRealData.visit(seqModifier)
seqModifier = ApplyFunctionToSequence(lambda module: setTrigger(
module,
cms.PSet(hltDBKey=cms.string('TauTriggerForALLEleDataset'),
hltPaths=cms.vstring(
'HLT_Ele20_CaloIdVT_CaloIsoVT_TrkIdT_TrkIsoVT_SC4_Mass50_v*'))
))
TauValNumeratorAndDenominatorRealElectronsData.visit(seqModifier)
seqModifier = ApplyFunctionToSequence(lambda module: setTrigger(
module,
cms.PSet(hltDBKey=cms.string('TauTriggerForALLMuDataset'),
hltPaths=cms.vstring('HLT_IsoMu24_eta2p1_v*'))))
TauValNumeratorAndDenominatorRealMuonsData.visit(seqModifier)
jetDQMAnalyzerAk4CaloUncleaned = DQMEDAnalyzer('JetAnalyzer',
JetType = cms.string('calo'),#pf, calo or jpt
JetCorrections = cms.InputTag("dqmAk4CaloL2L3ResidualCorrector"),
jetsrc = cms.InputTag("ak4CaloJets"),
METCollectionLabel = cms.InputTag("caloMet"),
muonsrc = cms.InputTag("muons"),
l1algoname = cms.string("L1Tech_BPTX_plus_AND_minus.v0"),
filljetHighLevel =cms.bool(False),
fillsubstructure =cms.bool(False),
ptMinBoosted = cms.double(400.),
#
#
#
highPtJetTrigger = cms.PSet(
andOr = cms.bool( False ),
dbLabel = cms.string("JetMETDQMTrigger"),
hltInputTag = cms.InputTag( "TriggerResults::HLT" ),
hltPaths = cms.vstring( 'HLT_PFJet450_v*'),
andOrHlt = cms.bool( True ),
errorReplyHlt = cms.bool( False ),
),
lowPtJetTrigger = cms.PSet(
andOr = cms.bool( False ),
dbLabel = cms.string("JetMETDQMTrigger"),
hltInputTag = cms.InputTag( "TriggerResults::HLT" ),
hltPaths = cms.vstring( 'HLT_PFJet80_v*'),
andOrHlt = cms.bool( True ),
errorReplyHlt = cms.bool( False ),
),
TriggerResultsLabel = cms.InputTag("TriggerResults::HLT"),
processname = cms.string("HLT"),
#
# Jet-related
#
JetCleaningFlag = cms.untracked.bool(False),
runcosmics = cms.untracked.bool(False),
#Cleanup parameters
CleaningParameters = cleaningParameters.clone(
bypassAllPVChecks = cms.bool(True),
),
#for JPT and CaloJetID
InputJetIDValueMap = cms.InputTag("ak4JetID"),
#options for Calo and JPT: LOOSE,LOOSE_AOD,TIGHT,MINIMAL
#for PFJets: LOOSE,TIGHT
JetIDQuality = cms.string("LOOSE"),
#options for Calo and JPT: PURE09,DQM09,CRAFT08
#for PFJets: FIRSTDATA
JetIDVersion = cms.string("PURE09"),
#
#actually done only for PFJets at the moment
InputMVAPUIDDiscriminant = cms.InputTag("pileupJetIdEvaluatorDQM","fullDiscriminant"),
InputCutPUIDDiscriminant = cms.InputTag("pileupJetIdEvaluatorDQM","cutbasedDiscriminant"),
InputMVAPUIDValue = cms.InputTag("pileupJetIdEvaluatorDQM","fullId"),
InputCutPUIDValue = cms.InputTag("pileupJetIdEvaluatorDQM","cutbasedId"),
InputQGMultiplicity = cms.InputTag("QGTagger", "mult"),
InputQGLikelihood = cms.InputTag("QGTagger", "qgLikelihood"),
InputQGPtDToken = cms.InputTag("QGTagger", "ptD"),
InputQGAxis2 = cms.InputTag("QGTagger", "axis2"),
fillCHShistos =cms.bool(False),
#
# For jetAnalysis
#
jetAnalysis = jetDQMParameters.clone(),
#
# DCS
#
DCSFilterForJetMonitoring = cms.PSet(
DetectorTypes = cms.untracked.string("ecal:hbhe:hf"),
#DebugOn = cms.untracked.bool(True),
alwaysPass = cms.untracked.bool(False)
)
)
SiStripMonitorTrackIB.TkHistoMap_On = cms.bool(False)
SiStripMonitorTrackIB.TH1ClusterNoise.layerView = cms.bool(False)
SiStripMonitorTrackIB.TH1ClusterWidth.layerView = cms.bool(False)
SiStripMonitorTrackIB.TH1ClusterChargePerCM.ringView = cms.bool(False)
SiStripMonitorTrackIB.TopFolderName = cms.string("SiStrip/IsolatedBunches")
### TrackerMonitorTrack defined and used only for MinimumBias ####
from DQM.TrackerMonitorTrack.MonitorTrackResiduals_cfi import *
MonitorTrackResiduals.trajectoryInput = 'refittedForPixelDQM'
MonitorTrackResiduals.Tracks = 'refittedForPixelDQM'
MonitorTrackResiduals.Mod_On = False
MonitorTrackResiduals.genericTriggerEventPSet = genericTriggerEventFlag4HLTdb
# DQM Services
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
dqmInfoSiStrip = DQMEDAnalyzer('DQMEventInfo',
subSystemFolder=cms.untracked.string('SiStrip'))
# Services needed for TkHistoMap
from CalibTracker.SiStripCommon.TkDetMapESProducer_cfi import *
# Event History Producer
from DPGAnalysis.SiStripTools.eventwithhistoryproducerfroml1abc_cfi import *
# APV Phase Producer
from DPGAnalysis.SiStripTools.apvcyclephaseproducerfroml1tsDB_cfi import *
# temporary patch in order to have BXlumi
from RecoLuminosity.LumiProducer.lumiProducer_cff import *
# Sequence
#removed modules using TkDetMap service
hltDBKey = cms.string(''),
errorReplyHlt = cms.bool(False),
verbosityLevel = cms.uint32(1)
)
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
mssmHbbBtagTriggerMonitor = DQMEDAnalyzer(
"TagAndProbeBtagTriggerMonitor",
dirname = cms.string("HLT/Higgs/MssmHbb/"),
processname = cms.string("HLT"),
jetPtMin = cms.double(40),
jetEtaMax = cms.double(2.2),
tagBtagMin = cms.double(0.95),
probeBtagMin = cms.double(0.84),
triggerobjbtag = cms.string("hltBTagCalo30x8CSVp0p92SingleWithMatching"),
triggerSummary = cms.InputTag("hltTriggerSummaryAOD","","HLT"),
offlineBtag = cms.InputTag("pfCombinedInclusiveSecondaryVertexV2BJetTags"),
histoPSet = cms.PSet(
jetPt = cms.vdouble(40,45,50,55,60,65,70,75,80,85,90,95,100),
jetEta = cms.vdouble(-2.5,-2.0,-1.5,-1.0,-0.5,0.0,0.5,1.0,1.5,2.0,2.5),
jetPhi = cms.vdouble(-3.5,-3.0,-2.5,-2.0,-1.5,-1.0,-0.5,0.0,0.5,1.0,1.5,2.0,2.5,3.0,3.5),
jetBtag = cms.vdouble(0.80,0.81,0.82,0.83,0.84,0.85,0.86,0.87,0.88,0.89,0.90,0.91,0.92,0.93,0.94,0.95,0.96,0.97,0.98,0.99,1.00),
),
genericTriggerEventPSet = triggerFlagPSet.clone(),
)
# online btagging monitor
mssmHbbBtagTriggerMonitorSL40noMu = mssmHbbBtagTriggerMonitor.clone()
mssmHbbBtagTriggerMonitorSL40noMu.dirname = cms.string("HLT/Higgs/MssmHbb/semileptonic/BtagTrigger/pt40_noMuon")
muonTrackValidator = DQMEDAnalyzer(
'MuonTrackValidator',
# input TrackingParticle collections
label_tp_effic=cms.InputTag("mix", "MergedTrackTruth"),
label_tp_fake=cms.InputTag("mix", "MergedTrackTruth"),
# input reco::Track collection
label=cms.VInputTag(cms.InputTag("globalMuons")),
# switches to be set according to the input Track collection to properly count SimHits
usetracker=cms.bool(True),
usemuon=cms.bool(True),
#
useGsf=cms.bool(False),
beamSpot=cms.InputTag("offlineBeamSpot"),
# set true if you do not want that MTV launch an exception
# if the track collection is missing (e.g. HLT):
ignoremissingtrackcollection=cms.untracked.bool(False),
#
# selection of TP for evaluation of efficiency, from "TrackingParticleSelectionForEfficiency"
signalOnlyTP=cms.bool(True),
intimeOnlyTP=cms.bool(False),
stableOnlyTP=cms.bool(False),
chargedOnlyTP=cms.bool(True),
pdgIdTP=cms.vint32(13, -13),
minHitTP=cms.int32(0),
ptMinTP=cms.double(0.9),
ptMaxTP=cms.double(1e100),
minRapidityTP=cms.double(-2.4),
maxRapidityTP=cms.double(2.4),
tipTP=cms.double(3.5),
lipTP=cms.double(30.0),
# collision-like tracks
parametersDefiner=cms.string('LhcParametersDefinerForTP'),
# cosmics tracks
# parametersDefiner = cms.string('CosmicParametersDefinerForTP'),
#
# map linking SimHits to TrackingParticles, needed for cosmics validation`
simHitTpMapTag=cms.InputTag("simHitTPAssocProducer"),
#
# if *not* uses associators, the TP-RecoTrack maps has to be specified
UseAssociators=cms.bool(False),
useGEMs=cms.bool(False),
useME0=cms.bool(False),
associators=cms.vstring('a_MuonAssociator'),
associatormap=cms.InputTag("tpToMuonTrackAssociation"),
#
# BiDirectional Logic for RecoToSim association corrects the Fake rates (counting ghosts and split tracks as fakes)
# setting it to False the ghost and split tracks are counted as good ones (old setting of Muon Validation up to CMSSW_3_6_0_pre4)
# the default setting is True: should NOT be changed !
BiDirectional_RecoToSim_association=cms.bool(True),
#
# Output File / Directory
outputFile=cms.string(''),
dirName=cms.string('Muons/RecoMuonV/MultiTrack/'),
#
# Parameters for plots
useFabsEta=cms.bool(False),
min=cms.double(-2.5),
max=cms.double(2.5),
nint=cms.int32(50),
#
ptRes_nbin=cms.int32(100),
ptRes_rangeMin=cms.double(-0.3),
ptRes_rangeMax=cms.double(0.3),
#
phiRes_nbin=cms.int32(100),
phiRes_rangeMin=cms.double(-0.05),
phiRes_rangeMax=cms.double(0.05),
#
etaRes_rangeMin=cms.double(-0.05),
etaRes_rangeMax=cms.double(0.05),
#
cotThetaRes_nbin=cms.int32(120),
cotThetaRes_rangeMin=cms.double(-0.01),
cotThetaRes_rangeMax=cms.double(0.01),
#
dxyRes_nbin=cms.int32(100),
dxyRes_rangeMin=cms.double(-0.02),
dxyRes_rangeMax=cms.double(0.02),
#
dzRes_nbin=cms.int32(150),
dzRes_rangeMin=cms.double(-0.05),
dzRes_rangeMax=cms.double(0.05),
#
minpT=cms.double(0.1),
maxpT=cms.double(1500),
nintpT=cms.int32(40),
useLogPt=cms.untracked.bool(False),
useInvPt=cms.bool(False),
#
minHit=cms.double(-0.5),
maxHit=cms.double(74.5),
nintHit=cms.int32(75),
#
minPhi=cms.double(-3.1416),
maxPhi=cms.double(3.1416),
nintPhi=cms.int32(36),
#
minDxy=cms.double(-3),
maxDxy=cms.double(3),
nintDxy=cms.int32(100),
#
minDz=cms.double(-10),
maxDz=cms.double(10),
nintDz=cms.int32(100),
# TP originating vertical position
minVertpos=cms.double(0),
maxVertpos=cms.double(5),
nintVertpos=cms.int32(100),
# TP originating z position
minZpos=cms.double(-10),
maxZpos=cms.double(10),
nintZpos=cms.int32(100))
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from SimTracker.TrackHistory.TrackClassifier_cff import *
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
BDHadronTrackMonitoringAnalyze = DQMEDAnalyzer(
'BDHadronTrackMonitoringAnalyzer',
trackClassifier,
distJetAxisCut=cms.double(0.07),
decayLengthCut=cms.double(5.0),
minJetPt=cms.double(20),
maxJetEta=cms.double(2.5),
PatJetSource=cms.InputTag('selectedPatJets'),
ipTagInfos=cms.string('pfImpactParameter'),
TrackSource=cms.InputTag('generalTracks'),
PrimaryVertexSource=cms.InputTag('offlinePrimaryVertices'),
clusterTPMap=cms.InputTag("tpClusterProducer"),
)
BDHadronTrackMonitoringHarvest = DQMEDHarvester(
"BDHadronTrackMonitoringHarvester")
OuterTrackerMonitorTrackingParticles = DQMEDAnalyzer(
'OuterTrackerMonitorTrackingParticles',
TopFolderName=cms.string('SiOuterTrackerV'),
trackingParticleToken=cms.InputTag(
"mix", "MergedTrackTruth"), #tracking particles
MCTruthStubInputTag=cms.InputTag("TTStubAssociatorFromPixelDigis",
"StubAccepted"), #truth stub associator
MCTruthTrackInputTag=cms.InputTag(
"TTTrackAssociatorFromPixelDigis",
"Level1TTTracks"), #truth track associator
MCTruthClusterInputTag=cms.InputTag(
"TTClusterAssociatorFromPixelDigis",
"ClusterAccepted"), #truth cluster associator
L1Tk_minNStub=cms.int32(4), # L1 tracks with >= 4 stubs
L1Tk_maxChi2dof=cms.double(25.0), # L1 tracks with Chi2 <= X
TP_minNStub=cms.int32(
4), # require TP to have >= X number of stubs associated with it
TP_minNLayersStub=cms.int32(
4), # require TP to have >= X number of layers hit with stubs
TP_minPt=cms.double(2.0), # only save TPs with pt > X GeV
TP_maxEta=cms.double(2.4), # only save TPs with |eta| < X
TP_maxVtxZ=cms.double(15.0), # only save TPs with |z0| < X cm
# tracking particles vs eta
TH1TrackParts_Eta=cms.PSet(Nbinsx=cms.int32(45),
xmax=cms.double(3),
xmin=cms.double(-3)),
# tracking particles vs phi
TH1TrackParts_Phi=cms.PSet(Nbinsx=cms.int32(60),
xmax=cms.double(math.pi),
xmin=cms.double(-math.pi)),
# tracking particles vs pT
TH1TrackParts_Pt=cms.PSet(Nbinsx=cms.int32(45),
xmax=cms.double(100),
xmin=cms.double(0)),
# tracking particles vs pT_relative
TH1Res_ptRel=cms.PSet(Nbinsx=cms.int32(200),
xmax=cms.double(0.5),
xmin=cms.double(-0.5)),
# tracking particles vs pT (for efficiency)
TH1Effic_pt=cms.PSet(Nbinsx=cms.int32(50),
xmax=cms.double(100),
xmin=cms.double(0)),
# tracking particles vs pT (for efficiency)
TH1Effic_pt_zoom=cms.PSet(Nbinsx=cms.int32(50),
xmax=cms.double(10),
xmin=cms.double(0)),
# tracking particles vs eta (for efficiency)
TH1Effic_eta=cms.PSet(Nbinsx=cms.int32(50),
xmax=cms.double(2.5),
xmin=cms.double(-2.5)),
# tracking particles vs d0 (for efficiency)
TH1Effic_d0=cms.PSet(Nbinsx=cms.int32(50),
xmax=cms.double(2),
xmin=cms.double(-2)),
# tracking particles vs VtxR/vxy (for efficiency)
TH1Effic_VtxR=cms.PSet(Nbinsx=cms.int32(50),
xmax=cms.double(5),
xmin=cms.double(-5)),
# tracking particles vs z0 (for efficiency)
TH1Effic_VtxZ=cms.PSet(Nbinsx=cms.int32(50),
xmax=cms.double(30),
xmin=cms.double(-30)),
# tracking particles vs relative pT (for resolution plots)
TH1Res_pt=cms.PSet(Nbinsx=cms.int32(100),
xmax=cms.double(0.2),
xmin=cms.double(-0.2)),
# tracking particles vs eta (for resolution)
TH1Res_eta=cms.PSet(Nbinsx=cms.int32(100),
xmax=cms.double(0.01),
xmin=cms.double(-0.01)),
# tracking particles vs phi (for resolution)
TH1Res_phi=cms.PSet(Nbinsx=cms.int32(100),
xmax=cms.double(0.01),
xmin=cms.double(-0.01)),
# tracking particles vs z0 (for resolution)
TH1Res_VtxZ=cms.PSet(Nbinsx=cms.int32(100),
xmax=cms.double(1.0),
xmin=cms.double(-1.0)),
# tracking particles vs d0 (for resolution)
TH1Res_d0=cms.PSet(Nbinsx=cms.int32(100),
xmax=cms.double(0.05),
xmin=cms.double(-0.05)),
)
topSingleLeptonHLTOfflineDQM = DQMEDAnalyzer(
'TopSingleLeptonHLTOfflineDQM',
## ------------------------------------------------------
## SETUP
##
## configuration of the MonitoringEnsemble(s)
## [mandatory] : optional PSets may be omitted
##
setup=cms.PSet(
## sub-directory to write the monitor histograms to
## [mandatory] : should not be changed w/o explicit
## communication to TopCom!
directory=cms.string("HLT/TOP/SemiLeptonic/"),
## [mandatory]
sources=cms.PSet(muons=cms.InputTag("muons"),
elecs=cms.InputTag("gedGsfElectrons"),
jets=cms.InputTag("ak4PFJetsCHS"),
mets=cms.VInputTag("met", "tcMet", "pfMet"),
pvs=cms.InputTag("offlinePrimaryVertices")),
## [optional] : when omitted all monitoring plots for primary vertices
## will be filled w/o extras
pvExtras=cms.PSet(
## when omitted electron plots will be filled w/o additional pre-
## selection of the primary vertex candidates
select=cms.string(
"abs(x)<1. & abs(y)<1. & abs(z)<20. & tracksSize>3 & !isFake")
),
## [optional] : when omitted all monitoring plots for electrons
## will be filled w/o extras
elecExtras=cms.PSet(
## when omitted electron plots will be filled w/o cut on electronId
#electronId = cms.PSet( src = cms.InputTag("mvaTrigV0"), pattern = cms.int32(1) ),
## when omitted electron plots will be filled w/o additional pre-
## selection of the electron candidates
select=cms.string("pt>30 & abs(eta)<2.5"),
## when omitted isolated electron multiplicity plot will be equi-
## valent to inclusive electron multiplicity plot
isolation=cms.string(
"(dr03TkSumPt+dr04EcalRecHitSumEt+dr04HcalTowerSumEt)/pt<0.1"),
),
## [optional] : when omitted all monitoring plots for muons
## will be filled w/o extras
muonExtras=cms.PSet(
## when omitted muon plots will be filled w/o additional pre-
## selection of the muon candidates
select=cms.string(
"pt>26 & abs(eta)<2.1 & isPFMuon & isGlobalMuon & globalTrack.normalizedChi2<10 & innerTrack.hitPattern.trackerLayersWithMeasurement>5 & innerTrack.hitPattern.numberOfValidPixelHits>0 & numberOfMatches>1"
),
## when omitted isolated muon multiplicity plot will be equi-
## valent to inclusive muon multiplicity plot
isolation=cms.string(
"(pfIsolationR04.sumChargedHadronPt+pfIsolationR04.sumPhotonEt+pfIsolationR04.sumNeutralHadronEt)/pt<0.2"
),
),
## [optional] : when omitted all monitoring plots for jets will
## be filled from uncorrected jets
jetExtras=cms.PSet(
## when omitted monitor plots for pt will be filled from uncorrected
## jets
#jetCorrector = cms.string("ak4PFCHSL2L3"),
## when omitted no extra selection will be applied on jets before
## filling the monitor histograms; if jetCorrector is present the
## selection will be applied to corrected jets
select=cms.string("pt>20 & abs(eta)<2.5"), ),
## [optional] : when omitted no mass window will be applied
## for the W mass befor filling the event monitoring plots
massExtras=cms.PSet(lowerEdge=cms.double(70.),
upperEdge=cms.double(110.)),
## [optional] : when omitted the monitoring plots for triggering
## will be empty
#triggerExtras = cms.PSet(
# src = cms.InputTag("TriggerResults","","HLT"),
# paths = cms.vstring(['HLT_Mu3:HLT_QuadJet15U',
# 'HLT_Mu5:HLT_QuadJet15U',
# 'HLT_Mu7:HLT_QuadJet15U',
# 'HLT_Mu9:HLT_QuadJet15U'])
#)
),
## ------------------------------------------------------
## PRESELECTION
##
## setup of the event preselection, which will not
## be monitored
## [mandatory] : but may be empty
##
preselection=cms.PSet(
trigger=cms.PSet(
src=cms.InputTag("TriggerResults", "", "HLT"),
### Updating to HLT paths to be monitored by TOP PAG in 2017
select=cms.vstring([
'HLT_IsoMu27_v',
'HLT_Mu50_v'
'HLT_Ele35_WPTight_Gsf_v',
'HLT_Ele38_WPTight_Gsf_v',
'HLT_Ele40_WPTight_Gsf_v',
]),
),
## [optional] : when omitted no preselection is applied
vertex=cms.PSet(
src=cms.InputTag("offlinePrimaryVertices"),
select=cms.string(
'abs(x)<1. & abs(y)<1. & abs(z)<20. & tracksSize>3 & !isFake'))
),
## ------------------------------------------------------
## SELECTION
##
## monitor histrograms are filled after each selection
## step, the selection is applied in the order defined
## by this vector
## [mandatory] : may be empty or contain an arbitrary
## number of PSets
##
selection=cms.VPSet(
cms.PSet(
label=cms.string("Hlt:step0"),
src=cms.InputTag(""),
select=cms.string(""),
min=cms.int32(0),
max=cms.int32(0),
),
cms.PSet(
label=cms.string("jets/pf:step1"),
src=cms.InputTag("ak4PFJetsCHS"),
select=cms.string("pt>20 & abs(eta)<2.5"),
min=cms.int32(4),
),
))
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
HcalSimHitsAnalyser = DQMEDAnalyzer('HcalSimHitsValidation',
outputFile=cms.untracked.string(''),
hf1=cms.double(1 / 0.383),
hf2=cms.double(1 / 0.368))
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(HcalSimHitsAnalyser,
ModuleLabel=cms.untracked.string("fastSimProducer"))
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
run2_HCAL_2017.toModify(HcalSimHitsAnalyser,
TestNumber=cms.untracked.bool(True))
from Configuration.Eras.Modifier_phase2_hcal_cff import phase2_hcal
phase2_hcal.toModify(HcalSimHitsAnalyser,
EEHitCollection=cms.untracked.string(""))
# post-LS1 switch for sampling factors
from Configuration.Eras.Modifier_run2_common_cff import run2_common
run2_common.toModify(HcalSimHitsAnalyser,
hf1=cms.double(1 / 0.67),
hf2=cms.double(1 / 0.67))
#----------------------------
# pixelVertexDQM Config
#----------------------------
process.pixelVertexDQM = DQMEDAnalyzer('Vx3DHLTAnalyzer',
vertexCollection = cms.untracked.InputTag("pixelVertices"),
pixelHitCollection = cms.untracked.InputTag("siPixelRecHitsPreSplitting"),
debugMode = cms.bool(True),
nLumiFit = cms.uint32(2),
maxLumiIntegration = cms.uint32(15),
nLumiXaxisRange = cms.uint32(5000),
dataFromFit = cms.bool(True),
minNentries = cms.uint32(20),
# If the histogram has at least "minNentries" then extract Mean and RMS,
# or, if we are performing the fit, the number of vertices must be greater
# than minNentries otherwise it waits for other nLumiFit
xRange = cms.double(0.8),
xStep = cms.double(0.001),
yRange = cms.double(0.8),
yStep = cms.double(0.001),
zRange = cms.double(30.0),
zStep = cms.double(0.04),
VxErrCorr = cms.double(1.2), # Keep checking this with later release
minVxDoF = cms.double(10.0),
minVxWgt = cms.double(0.5),
fileName = cms.string("/nfshome0/dqmdev/BeamMonitorDQM/BeamPixelResults.txt"))
#----------------------------
# Heavy Ion Specific Section
#----------------------------
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
dtResolutionTaskHLT = DQMEDAnalyzer('DTResolutionAnalysisTask',
# labels of 4D hits
recHits4DLabel = cms.string('hltDt4DSegments'),
# interval of lumi block after which we reset the histos
ResetCycle = cms.untracked.int32(10000),
# top folder for the histograms in DQMStore
topHistoFolder = cms.untracked.string('HLT/HLTMonMuon/DT-Segments')
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDHarvester import DQMEDHarvester
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
SUSY_HLT_Muon_BJet = DQMEDAnalyzer(
'SUSY_HLT_Muon_BJet',
trigSummary=cms.InputTag("hltTriggerSummaryAOD", '',
'HLT'), #to use with test sample
MuonCollection=cms.InputTag("muons"),
pfJetCollection=cms.InputTag("ak4PFJetsCHS"),
caloJetCollection=cms.InputTag("ak4CaloJets"),
TriggerResults=cms.InputTag('TriggerResults', '',
'HLT'), #to use with test sample
HLTProcess=cms.string('HLT'),
TriggerPath=cms.string('HLT_Mu10_CentralPFJet30_BTagCSV_p13_v'),
TriggerFilterMuon=cms.InputTag('hltL3fL1sMu0L1f0L2f3QL3Filtered10Q', '',
'HLT'),
TriggerFilterJet=cms.InputTag('hltBTagPFCSVp13Single', '',
'HLT'), #the last filter in the path
PtThrJet=cms.untracked.double(30.0),
EtaThrJet=cms.untracked.double(3.0))
SUSYoHLToMuonBJetPOSTPROCESSING = DQMEDHarvester(
"DQMGenericClient",
subDirs=cms.untracked.vstring(
"HLT/SUSYBSM/HLT_Mu10_CentralPFJet30_BTagCSV_p13_v"),
verbose=cms.untracked.uint32(2), # Set to 2 for all messages
resolution=cms.vstring(""),
efficiency=cms.vstring(
"pfHTTurnOn_eff 'Turn-on vs HT; PFHT (GeV); #epsilon' pfHTTurnOn_num pfHTTurnOn_den",
"MuTurnOn_eff 'Turn-on vs Mu pT; pT (GeV); #epsilon' MuTurnOn_num MuTurnOn_den",
hgcalValidator = DQMEDAnalyzer(
"HGCalValidator",
### general settings ###
# selection of CP for evaluation of efficiency #
CaloParticleSelectionForEfficiency,
### reco input configuration ###
#2DLayerClusters, PFClusters, Tracksters
label_lcl=layerClusterCaloParticleAssociation.label_lc,
label_tst=cms.VInputTag(labelTst),
associator=cms.untracked.InputTag(
"layerClusterCaloParticleAssociationProducer"),
associatorSim=cms.untracked.InputTag(
"layerClusterSimClusterAssociationProducer"),
#General info on layers etc.
SaveGeneralInfo=cms.untracked.bool(True),
#CaloParticle related plots
doCaloParticlePlots=cms.untracked.bool(True),
#Select caloParticles for efficiency or pass through
doCaloParticleSelection=cms.untracked.bool(True),
#SimCluster related plots
doSimClustersPlots=cms.untracked.bool(True),
#Layer Cluster related plots
doLayerClustersPlots=cms.untracked.bool(True),
#Trackster related plots
doTrackstersPlots=cms.untracked.bool(True),
#The cumulative material budget in front of each layer. To be more specific, it
#is the material budget just in front of the active material (not including it).
#This file is created using the official material budget code.
cummatbudinxo=cms.FileInPath(
'Validation/HGCalValidation/data/D41.cumulative.xo'),
### sim input configuration ###
label_cp_effic=layerClusterCaloParticleAssociation.label_cp,
label_cp_fake=cms.InputTag("mix", "MergedCaloTruth"),
#simClusters
label_scl=layerClusterSimClusterAssociation.label_scl,
simVertices=cms.InputTag("g4SimHits"),
LayerClustersInputMask=cms.VInputTag(lcInputMask),
#Total number of layers of HGCal that we want to monitor
#Could get this also from HGCalImagingAlgo::maxlayer but better to get it from here
totallayers_to_monitor=cms.int32(52),
#Thicknesses we want to monitor. -1 is for scintillator
thicknesses_to_monitor=cms.vint32(120, 200, 300, -1),
# HistoProducerAlgo. Defines the set of plots to be booked and filled
histoProducerAlgoBlock=HGVHistoProducerAlgoBlock,
### output configuration
dirName=cms.string('HGCAL/HGCalValidator/'))
hltTauOfflineMonitor_PFTaus = DQMEDAnalyzer('HLTTauDQMOfflineSource',
HLTProcessName = cms.untracked.string(hltTauDQMofflineProcess),
DQMBaseFolder = cms.untracked.string("HLT/TAU/PFTaus"),
TriggerResultsSrc = cms.untracked.InputTag("TriggerResults", "", hltTauDQMofflineProcess),
TriggerEventSrc = cms.untracked.InputTag("hltTriggerSummaryAOD", "", hltTauDQMofflineProcess),
L1Plotter = cms.untracked.PSet(
DQMFolder = cms.untracked.string('L1'),
L1Taus = cms.untracked.InputTag("caloStage2Digis", "Tau"),
L1ETM = cms.untracked.InputTag("caloStage2Digis","EtSum"),
L1ETMMin = cms.untracked.double(50),
),
Paths = cms.untracked.string("PFTau"),
PathSummaryPlotter = cms.untracked.PSet(
DQMFolder = cms.untracked.string('Summary'),
),
Matching = cms.PSet(
doMatching = cms.untracked.bool(True),
matchFilters = cms.untracked.VPSet(
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","PFTaus"),
matchObjectID = cms.untracked.int32(15),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","Electrons"),
matchObjectID = cms.untracked.int32(11),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","Muons"),
matchObjectID = cms.untracked.int32(13),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","MET"),
matchObjectID = cms.untracked.int32(0),
),
),
),
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
hgcalHitValidation = DQMEDAnalyzer(
'HGCalHitValidation',
geometrySource=cms.untracked.vstring("HGCalEESensitive",
"HGCalHESiliconSensitive", "Hcal"),
eeSimHitSource=cms.InputTag("g4SimHits", "HGCHitsEE"),
fhSimHitSource=cms.InputTag("g4SimHits", "HGCHitsHEfront"),
bhSimHitSource=cms.InputTag("g4SimHits", "HcalHits"),
eeRecHitSource=cms.InputTag("HGCalRecHit", "HGCEERecHits"),
fhRecHitSource=cms.InputTag("HGCalRecHit", "HGCHEFRecHits"),
bhRecHitSource=cms.InputTag("HGCalRecHit", "HGCHEBRecHits"),
ietaExcludeBH=cms.vint32([]),
ifHCAL=cms.bool(False),
ifHCALsim=cms.bool(True),
)
from Validation.HGCalValidation.hgcalHitCalibration_cfi import hgcalHitCalibration
from Validation.HGCalValidation.caloparticlevalidation_cfi import caloparticlevalidation
hgcalHitValidationSequence = cms.Sequence(hgcalHitValidation +
hgcalHitCalibration +
caloparticlevalidation)
from Configuration.Eras.Modifier_phase2_hgcalV9_cff import phase2_hgcalV9
phase2_hgcalV9.toModify(
hgcalHitValidation,
bhSimHitSource=cms.InputTag("g4SimHits", "HGCHitsHEback"),
geometrySource=cms.untracked.vstring("HGCalEESensitive",
"HGCalHESiliconSensitive",
l1tEtSumJetOfflineDQM = DQMEDAnalyzer(
"L1TStage2CaloLayer2Offline",
electronCollection=cms.InputTag("gedGsfElectrons"),
pfJetCollection=cms.InputTag("goodPFJetsForL1T"),
caloMETCollection=cms.InputTag("caloMetBE"),
# MET collection including HF
caloETMHFCollection=cms.InputTag("caloMet"),
pfMETNoMuCollection=cms.InputTag('l1tPFMetNoMuForDQM'),
conversionsCollection=cms.InputTag("allConversions"),
PVCollection=cms.InputTag("offlinePrimaryVerticesWithBS"),
beamSpotCollection=cms.InputTag("offlineBeamSpot"),
triggerInputTag=cms.InputTag('hltTriggerSummaryAOD', '', 'HLT'),
triggerProcess=cms.string('HLT'),
triggerResults=cms.InputTag('TriggerResults', '', 'HLT'),
triggerNames=cms.vstring(
'HLT_IsoMu18_v*',
'HLT_IsoMu20_v*',
'HLT_IsoMu22_v*',
'HLT_IsoMu24_v*',
'HLT_IsoMu27_v*',
'HLT_IsoMu30_v*',
),
stage2CaloLayer2JetSource=cms.InputTag("caloStage2Digis", "Jet"),
stage2CaloLayer2EtSumSource=cms.InputTag("caloStage2Digis", "EtSum"),
histFolderEtSum=cms.string('L1T/L1TObjects/L1TEtSum/L1TriggerVsReco'),
histFolderJet=cms.string('L1T/L1TObjects/L1TJet/L1TriggerVsReco'),
jetEfficiencyThresholds=cms.vdouble(jetEfficiencyThresholds),
metEfficiencyThresholds=cms.vdouble(metEfficiencyThresholds),
mhtEfficiencyThresholds=cms.vdouble(mhtEfficiencyThresholds),
ettEfficiencyThresholds=cms.vdouble(ettEfficiencyThresholds),
httEfficiencyThresholds=cms.vdouble(httEfficiencyThresholds),
jetEfficiencyBins=cms.vdouble(jetEfficiencyBins),
metEfficiencyBins=cms.vdouble(metEfficiencyBins),
mhtEfficiencyBins=cms.vdouble(mhtEfficiencyBins),
ettEfficiencyBins=cms.vdouble(ettEfficiencyBins),
httEfficiencyBins=cms.vdouble(httEfficiencyBins),
recoHTTMaxEta=cms.double(2.5),
recoMHTMaxEta=cms.double(2.5),
histDefinitions=cms.PSet(
nVertex=histDefinitions.nVertex.clone(),
ETvsET=histDefinitions.ETvsET.clone(),
PHIvsPHI=histDefinitions.PHIvsPHI.clone(),
# L1JetETvsCaloJetET_HB=histDefinitions.ETvsET.clone(
# name='L1JetETvsCaloJetET_HB',
# title='L1 Jet E_{T} vs Offline Jet E_{T} (HB); Offline Jet E_{T} (GeV); L1 Jet E_{T} (GeV)',
# )
),
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
recHitTask = DQMEDAnalyzer(
"RecHitTask",
# standard parameters
name=cms.untracked.string("RecHitTask"),
debug=cms.untracked.int32(0),
runkeyVal=cms.untracked.int32(0),
runkeyName=cms.untracked.string("pp_run"),
ptype=cms.untracked.int32(0),
mtype=cms.untracked.bool(True),
subsystem=cms.untracked.string("Hcal"),
# tags
tagHBHE=cms.untracked.InputTag("hbhereco"),
tagHO=cms.untracked.InputTag("horeco"),
tagHF=cms.untracked.InputTag("hfreco"),
tagRaw=cms.untracked.InputTag('rawDataCollector'),
# thresholds
thresh_unihf=cms.untracked.double(0.2),
# prerechits
hfPreRecHitsAvailable=cms.untracked.bool(False),
tagPreHF=cms.untracked.InputTag(""),
)
pfCandidateDQMAnalyzer = DQMEDAnalyzer('DQMPFCandidateAnalyzer',
CandType=cms.untracked.string('PFCand'),
PFCandidateLabel = cms.InputTag('particleFlow', ''),
ptMinCand = cms.double(1.),
hcalMin =cms.double(1.),
CleaningParameters = cleaningParameters.clone(
bypassAllPVChecks = cms.bool(False)
),
METDiagonisticsParameters = multPhiCorr_METDiagnostics,
FilterResultsLabelMiniAOD = cms.InputTag("TriggerResults::RECO"),
FilterResultsLabelMiniAOD2 = cms.InputTag("TriggerResults::reRECO"),
LSBegin = cms.int32(0),
LSEnd = cms.int32(-1),
HBHENoiseLabelMiniAOD = cms.string("Flag_HBHENoiseFilter"),
HBHENoiseFilterResultLabel = cms.InputTag("HBHENoiseFilterResultProducer", "HBHENoiseFilterResult"),
HBHENoiseIsoFilterResultLabel = cms.InputTag("HBHENoiseFilterResultProducer", "HBHEIsoNoiseFilterResult"),
verbose = cms.int32(0),
DCSFilter = cms.PSet(
DetectorTypes = cms.untracked.string("ecal:hbhe:hf:pixel:sistrip:es:muon"),
#DebugOn = cms.untracked.bool(True),
Filter = cms.untracked.bool(True)
),
)
hltTauValIdealMonitorMC = DQMEDAnalyzer('HLTTauDQMOfflineSource',
HLTProcessName = cms.untracked.string(hltTauValidationProcess_IDEAL),
DQMBaseFolder = cms.untracked.string("HLT/TAU/RelVal/MC"),
TriggerResultsSrc = cms.untracked.InputTag("TriggerResults", "", hltTauValidationProcess_IDEAL),
TriggerEventSrc = cms.untracked.InputTag("hltTriggerSummaryAOD", "", hltTauValidationProcess_IDEAL),
L1Plotter = cms.untracked.PSet(
DQMFolder = cms.untracked.string('L1'),
L1Taus = cms.untracked.InputTag("caloStage2Digis", "Tau"),
L1ETM = cms.untracked.InputTag("caloStage2Digis","EtSum"),
L1ETMMin = cms.untracked.double(50),
),
Paths = cms.untracked.string("PFTau"),
PathSummaryPlotter = cms.untracked.PSet(
DQMFolder = cms.untracked.string('Summary'),
),
Matching = cms.PSet(
doMatching = cms.untracked.bool(True),
matchFilters = cms.untracked.VPSet(
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauMCProducer","HadronicTauOneAndThreeProng"),
matchObjectID = cms.untracked.int32(15),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauMCProducer","LeptonicTauElectrons"),
matchObjectID = cms.untracked.int32(11),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauMCProducer","LeptonicTauMuons"),
matchObjectID = cms.untracked.int32(13),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauMCProducer","MET"),
matchObjectID = cms.untracked.int32(0),
),
),
),
)
l1tStage2uGMTIntermediateEMTFPosEmul = DQMEDAnalyzer(
"L1TStage2uGMTMuon",
muonProducer = cms.InputTag(emulatorModule, "imdMuonsEMTFPos"),
monitorDir = cms.untracked.string(ugmtEmuImdMuDqmDir+"/EMTF_pos"),
titlePrefix = cms.untracked.string("uGMT intermediate muon from EMTF pos. "),
verbose = cms.untracked.bool(False),
)
# compares the unpacked uGMT muon collection to the emulated uGMT muon collection
# only muons that do not match are filled in the histograms
l1tdeStage2uGMT = DQMEDAnalyzer(
"L1TStage2MuonComp",
muonCollection1 = cms.InputTag(unpackerModule, "Muon"),
muonCollection2 = cms.InputTag(emulatorModule),
monitorDir = cms.untracked.string(ugmtEmuDqmDir+"/data_vs_emulator_comparison"),
muonCollection1Title = cms.untracked.string("uGMT data"),
muonCollection2Title = cms.untracked.string("uGMT emulator"),
summaryTitle = cms.untracked.string("Summary of comparison between uGMT muons and uGMT emulator muons"),
verbose = cms.untracked.bool(False),
)
# compares the unpacked uGMT intermediate muon collection to the emulated uGMT intermediate muon collection
# only muons that do not match are filled in the histograms
l1tdeStage2uGMTIntermediateBMTF = l1tdeStage2uGMT.clone()
l1tdeStage2uGMTIntermediateBMTF.muonCollection1 = cms.InputTag(unpackerModule, "imdMuonsBMTF")
l1tdeStage2uGMTIntermediateBMTF.muonCollection2 = cms.InputTag(emulatorModule, "imdMuonsBMTF")
l1tdeStage2uGMTIntermediateBMTF.monitorDir = cms.untracked.string(ugmtEmuImdMuDqmDir+"/BMTF/data_vs_emulator_comparison")
l1tdeStage2uGMTIntermediateBMTF.summaryTitle = cms.untracked.string("Summary of uGMT intermediate muon from BMTF comparison between unpacked and emulated")
l1tdeStage2uGMTIntermediateBMTF.ignoreBin = cms.untracked.vint32(ignoreBins)
l1tdeStage2uGMTIntermediateOMTFNeg = l1tdeStage2uGMTIntermediateBMTF.clone()
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
dtEfficiencyMonitor = DQMEDAnalyzer(
'DTEfficiencyTask',
# switch for verbosity
debug=cms.untracked.bool(False),
# labels of 4D and 1D hits
recHits4DLabel=cms.untracked.string('dt4DSegments'),
recHitLabel=cms.untracked.string('dt1DRecHits'),
# interval of lumi block after which we reset the histos
ResetCycle=cms.untracked.int32(10000))
hltTauOfflineMonitor_PFTaus = DQMEDAnalyzer('HLTTauDQMOfflineSource',
HLTProcessName = cms.untracked.string(hltTauDQMofflineProcess),
DQMBaseFolder = cms.untracked.string("HLT/TAU/PFTaus"),
TriggerResultsSrc = cms.untracked.InputTag("TriggerResults", "", hltTauDQMofflineProcess),
TriggerEventSrc = cms.untracked.InputTag("hltTriggerSummaryAOD", "", hltTauDQMofflineProcess),
L1Plotter = cms.untracked.PSet(
DQMFolder = cms.untracked.string('L1'),
L1Taus = cms.untracked.InputTag("caloStage2Digis", "Tau"),
L1ETM = cms.untracked.InputTag("caloStage2Digis","EtSum"),
L1ETMMin = cms.untracked.double(50),
),
Paths = cms.untracked.string("PFTau"),
PtHistoBins = cms.untracked.int32(50),
PtHistoMax = cms.untracked.double(500),
PathSummaryPlotter = cms.untracked.PSet(
DQMFolder = cms.untracked.string('Summary'),
),
Matching = cms.PSet(
doMatching = cms.untracked.bool(True),
matchFilters = cms.untracked.VPSet(
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","PFTaus"),
matchObjectID = cms.untracked.int32(15),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","Electrons"),
matchObjectID = cms.untracked.int32(11),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","Muons"),
matchObjectID = cms.untracked.int32(13),
),
cms.untracked.PSet(
FilterName = cms.untracked.InputTag("TauRefProducer","MET"),
matchObjectID = cms.untracked.int32(0),
),
),
),
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
hcalRecHitsAnalyzer = DQMEDAnalyzer(
'HcalRecHitsAnalyzer',
TopFolderName=cms.string('HcalRecHitsD/HcalRecHitTask'),
# outputFile = cms.untracked.string('HcalRecHitValidationRelVal.root'),
outputFile=cms.untracked.string(''),
HBHERecHitCollectionLabel=cms.untracked.InputTag("hbhereco"),
HFRecHitCollectionLabel=cms.untracked.InputTag("hfreco"),
HORecHitCollectionLabel=cms.untracked.InputTag("horeco"),
EBRecHitCollectionLabel=cms.InputTag("ecalRecHit:EcalRecHitsEB"),
EERecHitCollectionLabel=cms.InputTag("ecalRecHit:EcalRecHitsEE"),
eventype=cms.untracked.string('multi'),
ecalselector=cms.untracked.string('yes'),
hcalselector=cms.untracked.string('all'),
hep17=cms.untracked.bool(False)
# useAllHistos = cms.untracked.bool(False)
)
from Configuration.Eras.Modifier_run2_HEPlan1_2017_cff import run2_HEPlan1_2017
run2_HEPlan1_2017.toModify(hcalRecHitsAnalyzer, hep17=True)
TrackMon = DQMEDAnalyzer('TrackingMonitor',
# input tags
numCut = cms.string(" pt >= 1 & quality('highPurity') "),
denCut = cms.string(" pt >= 1 "),
allTrackProducer = cms.InputTag("generalTracks"),
TrackProducer = cms.InputTag("generalTracks"),
SeedProducer = cms.InputTag("initialStepSeeds"),
TCProducer = cms.InputTag("initialStepTrackCandidates"),
MVAProducers = cms.vstring("initialStepClassifier1", "initialStepClassifier2"),
TrackProducerForMVA = cms.InputTag("initialStepTracks"),
ClusterLabels = cms.vstring('Tot'), # to decide which Seeds-Clusters correlation plots to have default is Total other options 'Strip', 'Pix'
beamSpot = cms.InputTag("offlineBeamSpot"),
primaryVertex = cms.InputTag('offlinePrimaryVertices'),
stripCluster = cms.InputTag('siStripClusters'),
pixelCluster = cms.InputTag('siPixelClusters'),
BXlumiSetup = BXlumiSetup.clone(),
genericTriggerEventPSet = cms.PSet(),
# lumi = cms.InputTag('lumiProducer'),
# # taken from
# # DPGAnalysis/SiStripTools/src/DigiLumiCorrHistogramMaker.cc
# # the scale factor 6.37 should follow the lumi prescriptions
# # AS SOON AS THE CORRECTED LUMI WILL BE AVAILABLE IT HAS TO BE SET TO 1.
# lumiScale = cms.double(6.37),
# PU monitoring
primaryVertexInputTags = cms.VInputTag(),
selPrimaryVertexInputTags = cms.VInputTag(),
pvLabels = cms.vstring(),
# output parameters
AlgoName = cms.string('GenTk'),
Quality = cms.string(''),
FolderName = cms.string('Tracking/GlobalParameters'),
BSFolderName = cms.string('Tracking/ParametersVsBeamSpot'),
PVFolderName = cms.string('Tracking/PrimaryVertices'),
# determines where to evaluate track parameters
# options: 'default' --> straight up track parametes
# 'ImpactPoint' --> evalutate at impact point
# 'InnerSurface' --> evalutate at innermost measurement state
# 'OuterSurface' --> evalutate at outermost measurement state
MeasurementState = cms.string('ImpactPoint'),
# which plots to do
doTestPlots = cms.bool(False),
doAllPlots = cms.bool(True),
doTrackerSpecific = cms.bool(False),
doBeamSpotPlots = cms.bool(False),
doPrimaryVertexPlots = cms.bool(False),
doSeedParameterHistos = cms.bool(False),
doTrackCandHistos = cms.bool(False),
doAllTrackCandHistos = cms.bool(False),
doDCAPlots = cms.bool(False),
doDCAwrtPVPlots = cms.bool(False),
doDCAwrt000Plots = cms.bool(False),
doSIPPlots = cms.bool(False),
doEffFromHitPatternVsPU = cms.bool(False),
doEffFromHitPatternVsBX = cms.bool(False),
doEffFromHitPatternVsLUMI = cms.bool(False),
pvNDOF = cms.int32(4),
pixelCluster4lumi = cms.InputTag('siPixelClustersPreSplitting'),
scal = cms.InputTag('scalersRawToDigi'),
useBPixLayer1 = cms.bool(False),
minNumberOfPixelsPerCluster = cms.int32(2), # from DQM/PixelLumi/python/PixelLumiDQM_cfi.py
minPixelClusterCharge = cms.double(15000.),
doGeneralPropertiesPlots = cms.bool(False),
doHitPropertiesPlots = cms.bool(False),
# doGoodTrackPlots = cms.bool(False),
doMeasurementStatePlots = cms.bool(True),
doProfilesVsLS = cms.bool(False),
doRecHitsPerTrackProfile = cms.bool(True),
doRecHitVsPhiVsEtaPerTrack = cms.bool(False),
doRecHitVsPtVsEtaPerTrack = cms.bool(False),
# doGoodTrackRecHitVsPhiVsEtaPerTrack = cms.bool(False),
doLayersVsPhiVsEtaPerTrack = cms.bool(False),
# doGoodTrackLayersVsPhiVsEtaPerTrack = cms.bool(False),
# doGoodTrack2DChi2Plots = cms.bool(False),
doThetaPlots = cms.bool(False),
doTrackPxPyPlots = cms.bool(False),
doPUmonitoring = cms.bool(False),
doPlotsVsBXlumi = cms.bool(False),
doPlotsVsGoodPVtx = cms.bool(True),
doPlotsVsLUMI = cms.bool(False),
doPlotsVsBX = cms.bool(False),
doHIPlots = cms.bool(False),
doMVAPlots = cms.bool(False),
qualityString = cms.string("highPurity"),
#which seed plots to do
doSeedNumberHisto = cms.bool(False),
doSeedLumiAnalysis = cms.bool(False),
doSeedVsClusterHisto = cms.bool(False),
doSeedPTHisto = cms.bool(False),
doSeedETAHisto = cms.bool(False),
doSeedPHIHisto = cms.bool(False),
doSeedPHIVsETAHisto = cms.bool(False),
doSeedThetaHisto = cms.bool(False),
doSeedQHisto = cms.bool(False),
doSeedDxyHisto= cms.bool(False),
doSeedDzHisto= cms.bool(False),
doSeedNRecHitsHisto= cms.bool(False),
doSeedNVsPhiProf= cms.bool(False),
doSeedNVsEtaProf= cms.bool(False),
doStopSource = cms.bool(False),
TTRHBuilder = cms.string('WithTrackAngle'),
# Luminosity based analysis
doLumiAnalysis = cms.bool(False),
# For plots vs LS
LSBin = cms.int32(2000),
LSMin = cms.double(0),
LSMax = cms.double(2000.),
# paramters of the Track
# ============================================================
# chi2
Chi2Bin = cms.int32(50),
Chi2Max = cms.double(199.5),
Chi2Min = cms.double(-0.5),
# chi2 dof
Chi2NDFBin = cms.int32(50),
Chi2NDFMax = cms.double(19.5),
Chi2NDFMin = cms.double(-0.5),
# chi^2 probability
Chi2ProbBin = cms.int32(100),
Chi2ProbMax = cms.double(1.0),
Chi2ProbMin = cms.double(0.0),
# Number of Tracks per Event
TkSizeBin = cms.int32(100),
TkSizeMax = cms.double(99.5),
TkSizeMin = cms.double(-0.5),
# Number of seeds per Event
TkSeedSizeBin = cms.int32(200),
TkSeedSizeMax = cms.double(999.5),
TkSeedSizeMin = cms.double(-0.5),
# Number of Track Cadidates per Event
TCSizeBin = cms.int32(200),
TCSizeMax = cms.double(999.5),
TCSizeMin = cms.double(-0.5),
# num rec hits
TrackQBin = cms.int32(8),
TrackQMax = cms.double(2.5),
TrackQMin = cms.double(-2.5),
# num rec hits in seed
SeedHitBin = cms.int32(6),
SeedHitMax = cms.double(5.5),
SeedHitMin = cms.double(-0.5),
# num rec hits per track candidate
TCHitBin = cms.int32(40),
TCHitMax = cms.double(39.5),
TCHitMin = cms.double(-0.5),
# num rec hits
RecHitBin = cms.int32(40),
RecHitMax = cms.double(39.5),
RecHitMin = cms.double(-0.5),
# mean rec hits
MeanHitBin = cms.int32(30),
MeanHitMax = cms.double(29.5),
MeanHitMin = cms.double(-0.5),
subdetectors = cms.vstring( "TIB", "TOB", "TID", "TEC", "PixBarrel", "PixEndcap", "Pixel", "Strip" ),
subdetectorBin = cms.int32(25),
# num rec hits lost
RecLostBin = cms.int32(10),
RecLostMax = cms.double(9.5),
RecLostMin = cms.double(-0.5),
# num layers
RecLayBin = cms.int32(25),
RecLayMax = cms.double(24.5),
RecLayMin = cms.double(-0.5),
# mean layers
MeanLayBin = cms.int32(25),
MeanLayMax = cms.double(24.5),
MeanLayMin = cms.double(-0.5),
# num TOB Layers
TOBLayBin = cms.int32(10),
TOBLayMax = cms.double(9.5),
TOBLayMin = cms.double(-0.5),
# num TIB Layers
TIBLayBin = cms.int32(6),
TIBLayMax = cms.double(5.5),
TIBLayMin = cms.double(-0.5),
# num TID Layers
TIDLayBin = cms.int32(6),
TIDLayMax = cms.double(5.5),
TIDLayMin = cms.double(-0.5),
# num TEC Layers
TECLayBin = cms.int32(15),
TECLayMax = cms.double(14.5),
TECLayMin = cms.double(-0.5),
# num PXB Layers
PXBLayBin = cms.int32(6),
PXBLayMax = cms.double(5.5),
PXBLayMin = cms.double(-0.5),
# num PXF Layers
PXFLayBin = cms.int32(6),
PXFLayMax = cms.double(5.5),
PXFLayMin = cms.double(-0.5),
# Track |p|
TrackPBin = cms.int32(100),
TrackPMax = cms.double(100),
TrackPMin = cms.double(0),
# Track pT
TrackPtBin = cms.int32(100),
TrackPtMax = cms.double(100),
TrackPtMin = cms.double(0.1),
# Track px
TrackPxBin = cms.int32(50),
TrackPxMax = cms.double(50.0),
TrackPxMin = cms.double(-50.0),
# Track py
TrackPyBin = cms.int32(50),
TrackPyMax = cms.double(50.0),
TrackPyMin = cms.double(-50.0),
# Track pz
TrackPzBin = cms.int32(50),
TrackPzMax = cms.double(50.0),
TrackPzMin = cms.double(-50.0),
# track theta
ThetaBin = cms.int32(32),
ThetaMax = cms.double(3.2),
ThetaMin = cms.double(0.0),
# track eta
EtaBin = cms.int32(26),
EtaMax = cms.double(2.5),
EtaMin = cms.double(-2.5),
# track phi
PhiBin = cms.int32(32),
PhiMax = cms.double(3.141592654),
PhiMin = cms.double(-3.141592654),
# Track |p| error
pErrBin = cms.int32(50),
pErrMax = cms.double(1.0),
pErrMin = cms.double(0.0),
# Track pT error
ptErrBin = cms.int32(50),
ptErrMax = cms.double(1.0),
ptErrMin = cms.double(0.0),
# Track px error
pxErrBin = cms.int32(50),
pxErrMax = cms.double(1.0),
pxErrMin = cms.double(0.0),
# Track py error
pyErrBin = cms.int32(50),
pyErrMax = cms.double(1.0),
pyErrMin = cms.double(0.0),
# Track pz error
pzErrBin = cms.int32(50),
pzErrMax = cms.double(1.0),
pzErrMin = cms.double(0.0),
# track eta error
etaErrBin = cms.int32(50),
etaErrMax = cms.double(0.1),
etaErrMin = cms.double(0.0),
# track phi Error
phiErrBin = cms.int32(50),
phiErrMax = cms.double(0.1),
phiErrMin = cms.double(0.0),
# PCA x position
VXBin = cms.int32(100),
VXMax = cms.double(0.5),
VXMin = cms.double(-0.5),
# PCA y position
VYBin = cms.int32(100),
VYMax = cms.double(0.5),
VYMin = cms.double(-0.5),
# PCA z position
VZBin = cms.int32(100),
VZMax = cms.double(30.0),
VZMin = cms.double(-30.0),
# PCA z position for profile
VZBinProf = cms.int32(100),
VZMaxProf = cms.double(0.2),
VZMinProf = cms.double(-0.2),
# PCA x position for 2D plot
X0Bin = cms.int32(100),
X0Max = cms.double(0.5),
X0Min = cms.double(-0.5),
# PCA y position for 2D plot
Y0Bin = cms.int32(100),
Y0Max = cms.double(0.5),
Y0Min = cms.double(-0.5),
# PCA z position for 2D plot
Z0Bin = cms.int32(120),
Z0Max = cms.double(60.0),
Z0Min = cms.double(-60.0),
# Track dxy (transverse impact parameter)
DxyBin = cms.int32(100),
DxyMax = cms.double(0.5),
DxyMin = cms.double(-0.5),
AbsDxyBin = cms.int32(120),
AbsDxyMin = cms.double(0.),
AbsDxyMax = cms.double(60.),
# Seed dxy (transverse impact parameter)
SeedDxyBin = cms.int32(100),
SeedDxyMax = cms.double(0.5),
SeedDxyMin = cms.double(-0.5),
# Seed dz (longitudinal impact parameter)
SeedDzBin = cms.int32(120),
SeedDzMax = cms.double(30.0),
SeedDzMin = cms.double(-30.0),
# Track Candidate dxy (transverse impact parameter)
TCDxyBin = cms.int32(100),
TCDxyMax = cms.double(100.0),
TCDxyMin = cms.double(-100.0),
# Track Candidate dz (transverse impact parameter)
TCDzBin = cms.int32(100),
TCDzMax = cms.double(400.0),
TCDzMin = cms.double(-400.0),
# Track selection MVA
MVABin = cms.int32(100),
MVAMin = cms.double(-1),
MVAMax = cms.double(1),
#######################################
## needed for tracksVScluster and seedVScluster
# NCluster Pixel
NClusPxBin = cms.int32(200),
NClusPxMax = cms.double(49999.5),
NClusPxMin = cms.double(-0.5),
# NCluster Strip
NClusStrBin = cms.int32(500),
NClusStrMax = cms.double(199999.5),
NClusStrMin = cms.double(-0.5),
# NCluster Vs Tracks
NTrk2DBin = cms.int32(50),
NTrk2DMax = cms.double(1999.5),
NTrk2DMin = cms.double(-0.5),
# PU monitoring
# Nunmber of Good Primary Vertices
GoodPVtxBin = cms.int32(200),
GoodPVtxMin = cms.double( 0.),
GoodPVtxMax = cms.double(200.),
LUMIBin = cms.int32 ( 300 ), # irrelevant
LUMIMin = cms.double( 200.),
LUMIMax = cms.double(20000.),
# # BXlumi
# BXlumiBin = cms.int32(400),
# BXlumiMin = cms.double(4000),
# BXlumiMax = cms.double(20000),
###############################
################## FOR HI PLOTS#####################
#######
TransDCABins = cms.int32(100),
TransDCAMin = cms.double(-8.0),
TransDCAMax = cms.double(8.0),
LongDCABins = cms.int32(100),
LongDCAMin = cms.double(-8.0),
LongDCAMax = cms.double(8.0),
)
),
noLineBreaks = cms.untracked.bool(True),
threshold = cms.untracked.string('DEBUG'),
DEBUG = cms.untracked.PSet(
limit = cms.untracked.int32(0)
)
),
categories = cms.untracked.vstring('tTrigdbValidation'),
destinations = cms.untracked.vstring('cout')
)
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
process.dtTTrigAnalyzer = DQMEDAnalyzer('DTtTrigDBValidation',
labelDBRef = cms.string('ttrigRef'),
labelDB = cms.string('ttrigToValidate'),
tTrigTestName = cms.string('tTrigDifferenceInRange')
#OutputMEsInRootFile = cms.untracked.bool(False),
#OutputFileName = cms.untracked.string('tTrigDBMonitoring_112281_vs_112237.root')
)
from DQMServices.Core.DQMQualityTester import DQMQualityTester
process.qTester = DQMQualityTester(
prescaleFactor = cms.untracked.int32(1),
qtList = cms.untracked.FileInPath('DQMOffline/CalibMuon/data/QualityTests.xml')
)
process.load("DQMServices.Components.DQMEnvironment_cfi")
process.dqmSaver.convention = 'Offline'
process.dqmSaver.workflow = '/Muon/DT/DTDBValidation'
process.p = cms.Path(process.dtTTrigAnalyzer*process.qTester*process.dqmSaver)
l1tMuonDQMOffline = DQMEDAnalyzer('L1TMuonDQMOffline',
histFolder = cms.untracked.string('L1T/L1TObjects/L1TMuon/L1TriggerVsReco'),
tagPtCut = cms.untracked.double(26.),
recoToL1PtCutFactor = cms.untracked.double(1.2),
cuts = cms.untracked.VPSet(cutsPSets),
useL1AtVtxCoord = cms.untracked.bool(True),
muonInputTag = cms.untracked.InputTag("muons"),
gmtInputTag = cms.untracked.InputTag("gmtStage2Digis","Muon"),
vtxInputTag = cms.untracked.InputTag("offlinePrimaryVertices"),
bsInputTag = cms.untracked.InputTag("offlineBeamSpot"),
triggerNames = cms.untracked.vstring(
"HLT_IsoMu27_v*",
"HLT_IsoMu30_v*"
),
trigInputTag = cms.untracked.InputTag("hltTriggerSummaryAOD", "", "HLT"),
trigProcess = cms.untracked.string("HLT"),
trigProcess_token = cms.untracked.InputTag("TriggerResults","","HLT"),
efficiencyVsPtBins = cms.untracked.vdouble(effVsPtBins),
efficiencyVsPhiBins = cms.untracked.vdouble(effVsPhiBins),
efficiencyVsEtaBins = cms.untracked.vdouble(effVsEtaBins),
efficiencyVsVtxBins = cms.untracked.vdouble(effVsVtxBins),
# muon track extrapolation to 2nd station
muProp = cms.PSet(
useTrack = cms.string("tracker"), # 'none' to use Candidate P4; or 'tracker', 'muon', 'global'
useState = cms.string("atVertex"), # 'innermost' and 'outermost' require the TrackExtra
useSimpleGeometry = cms.bool(True),
useStation2 = cms.bool(True),
fallbackToME1 = cms.bool(False),
),
verbose = cms.untracked.bool(False)
)
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
ledTask = DQMEDAnalyzer(
"LEDTask",
# standard parameters
name = cms.untracked.string("LEDTask"),
debug = cms.untracked.int32(0),
runkeyVal = cms.untracked.int32(0),
runkeyName = cms.untracked.string("pp_run"),
ptype = cms.untracked.int32(0),
mtype = cms.untracked.bool(True),
subsystem = cms.untracked.string("HcalCalib"),
# tags
tagHBHE = cms.untracked.InputTag("hcalDigis"),
tagHO = cms.untracked.InputTag("hcalDigis"),
tagHF = cms.untracked.InputTag("hcalDigis"),
tagRaw = cms.untracked.InputTag('hltHcalCalibrationRaw')
)
selectedOfflinePrimaryVerticesWithBS = selectedOfflinePrimaryVertices.clone()
selectedOfflinePrimaryVerticesWithBS.src = cms.InputTag('offlinePrimaryVerticesWithBS')
selectedPixelVertices = selectedOfflinePrimaryVertices.clone()
selectedPixelVertices.src = cms.InputTag('pixelVertices')
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
vertexAnalysis = DQMEDAnalyzer('PrimaryVertexAnalyzer4PUSlimmed',
use_only_charged_tracks = cms.untracked.bool(True),
do_generic_sim_plots = cms.untracked.bool(True),
verbose = cms.untracked.bool(False),
root_folder = cms.untracked.string("Vertexing/PrimaryVertexV"),
trackingParticleCollection = cms.untracked.InputTag("mix", "MergedTrackTruth"),
trackingVertexCollection = cms.untracked.InputTag("mix", "MergedTrackTruth"),
trackAssociatorMap = cms.untracked.InputTag("trackingParticleRecoTrackAsssociation"),
vertexAssociator = cms.untracked.InputTag("VertexAssociatorByPositionAndTracks"),
vertexRecoCollections = cms.VInputTag("offlinePrimaryVertices",
"offlinePrimaryVerticesWithBS",
"selectedOfflinePrimaryVertices",
"selectedOfflinePrimaryVerticesWithBS"
),
)
from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
premix_stage2.toModify(vertexAnalysis,
trackingParticleCollection = "mixData:MergedTrackTruth",
trackingVertexCollection = "mixData:MergedTrackTruth",
)
vertexAnalysisTrackingOnly = vertexAnalysis.clone(
vertexRecoCollections = vertexAnalysis.vertexRecoCollections.value() + [
import FWCore.ParameterSet.Config as cms
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
# Comparison of the unpacked uGT muon collections from uGT board 1 to those of boards 2 to 6.
l1tStage2uGTMuon1vsMuon2 = DQMEDAnalyzer(
"L1TStage2MuonComp",
muonCollection1 = cms.InputTag("gtStage2Digis", "Muon"),
muonCollection2 = cms.InputTag("gtStage2Digis", "Muon2"),
muonCollection1Title = cms.untracked.string("Muons uGT Board 1"),
muonCollection2Title = cms.untracked.string("Muons uGT Board 2"),
summaryTitle = cms.untracked.string("Summary of Comparison between Muons from uGT Board 1 and uGT Board 2"),
monitorDir = cms.untracked.string("L1T/L1TStage2uGT/uGTBoardComparisons/Board1vsBoard2/Muons"),
verbose = cms.untracked.bool(False),
)
l1tStage2uGTMuon1vsMuon3 = l1tStage2uGTMuon1vsMuon2.clone()
l1tStage2uGTMuon1vsMuon3.muonCollection2 = cms.InputTag("gtStage2Digis", "Muon3")
l1tStage2uGTMuon1vsMuon3.muonCollection2Title = cms.untracked.string("Muons uGT Board 3")
l1tStage2uGTMuon1vsMuon3.summaryTitle = cms.untracked.string("Summary of Comparison between Muons from uGT Board 1 and uGT Board 3")
l1tStage2uGTMuon1vsMuon3.monitorDir = cms.untracked.string("L1T/L1TStage2uGT/uGTBoardComparisons/Board1vsBoard3/Muons")
l1tStage2uGTMuon1vsMuon4 = l1tStage2uGTMuon1vsMuon2.clone()
l1tStage2uGTMuon1vsMuon4.muonCollection2 = cms.InputTag("gtStage2Digis", "Muon4")
l1tStage2uGTMuon1vsMuon4.muonCollection2Title = cms.untracked.string("Muons uGT Board 4")
l1tStage2uGTMuon1vsMuon4.summaryTitle = cms.untracked.string("Summary of Comparison between Muons from uGT Board 1 and uGT Board 4")
l1tStage2uGTMuon1vsMuon4.monitorDir = cms.untracked.string("L1T/L1TStage2uGT/uGTBoardComparisons/Board1vsBoard4/Muons")
l1tStage2uGTMuon1vsMuon5 = l1tStage2uGTMuon1vsMuon2.clone()
l1tStage2uGTMuon1vsMuon5.muonCollection2 = cms.InputTag("gtStage2Digis", "Muon5")
