def makeTnPFitter(process, suffix, categories):
fitter = cms.EDAnalyzer("TagProbeFitTreeAnalyzer",
#InputFileNames = cms.vstring("ntuple/tnpTree_%s.root" % mode),
InputFileNames = cms.vstring("tnpTree.root"),
InputDirectoryName = cms.string("tnp"+suffix),
InputTreeName = cms.string("fitter_tree"),
#OutputFileName = cms.string("result/result_%s_%s.root" % (suffix, mode)),
OutputFileName = cms.string("result.root"),
NumCPU = cms.uint32(1),
SaveWorkspace = cms.bool(False),
floatShapeParameters = cms.bool(True),
WeightVariable = cms.string("weight"),
Variables = cms.PSet(
mass = cms.vstring("Tag-Probe mass", "70.0", "110.0", "GeV/c^{2}"),
pt = cms.vstring("Probe p_{T}", "0", "1000", "GeV/c"),
abseta = cms.vstring("Probe |#eta|", "0", "2.5", ""),
event_nPV = cms.vstring("Number of vertex", "0", "30", ""),
weight = cms.vstring("Weight", "0.0", "2.0", ""),
),
Categories = cms.PSet(),
PDFs = basicPDFs,
binnedFit = cms.bool(True),
binsForFit = cms.uint32(50),
)
for cat in categories:
setattr(fitter, 'Efficiencies', tnpEffPSet(categories))
setattr(fitter.Categories, cat, cms.vstring(cat, "dummy[pass=1,fail=0]"))
setattr(process, 'fit'+suffix, fitter)
process.p += getattr(process, 'fit'+suffix)
def customise_L1simulation(process):
if (not hasattr(process, 'caloConfigSource')) :
process.load('L1Trigger.L1TCalorimeter.caloConfigStage1PP_cfi')
from L1Trigger.CSCTriggerPrimitives.cscTriggerPrimitiveDigis_cfi import cscTriggerPrimitiveDigis
process.simCscTriggerPrimitiveDigis = cscTriggerPrimitiveDigis
process.simCscTriggerPrimitiveDigis.commonParam.isSLHC = True
process.simCscTriggerPrimitiveDigis.commonParam.smartME1aME1b = True
from Validation.MuonGEMDigis.MuonGEMDigis_cff import me11tmbSLHCGEM
process.simCscTriggerPrimitiveDigis.commonParam.runME11ILT = cms.bool(True)
process.simCscTriggerPrimitiveDigis.me11tmbSLHCGEM = me11tmbSLHCGEM
process.simCscTriggerPrimitiveDigis.clctSLHC.clctNplanesHitPattern = 3
process.simCscTriggerPrimitiveDigis.clctSLHC.clctPidThreshPretrig = 2
process.simCscTriggerPrimitiveDigis.clctParam07.clctPidThreshPretrig = 2
process.simCscTriggerPrimitiveDigis.GEMPadDigiProducer = "simMuonGEMPadDigis"
from Validation.MuonGEMDigis.MuonGEMDigis_cff import me21tmbSLHCGEM
process.simCscTriggerPrimitiveDigis.commonParam.runME21ILT = cms.bool(True)
process.simCscTriggerPrimitiveDigis.me21tmbSLHCGEM = me21tmbSLHCGEM
## ME21 has its own SLHC processors
process.simCscTriggerPrimitiveDigis.alctSLHCME21 = process.simCscTriggerPrimitiveDigis.alctSLHC.clone()
process.simCscTriggerPrimitiveDigis.clctSLHCME21 = process.simCscTriggerPrimitiveDigis.clctSLHC.clone()
process.simCscTriggerPrimitiveDigis.alctSLHCME21.alctNplanesHitPattern = 3
#process.simCscTriggerPrimitiveDigis.alctSLHCME21.runME21ILT = cms.bool(True)
process.simCscTriggerPrimitiveDigis.clctSLHCME21.clctNplanesHitPattern = 3
process.simCscTriggerPrimitiveDigis.clctSLHCME21.clctPidThreshPretrig = 2
return process
def customiseFor2017DtUnpacking(process):
"""Adapt the HLT to run the legacy DT unpacking
for pre2018 data/MC workflows as the default"""
if hasattr(process,'hltMuonDTDigis'):
process.hltMuonDTDigis = cms.EDProducer( "DTUnpackingModule",
useStandardFEDid = cms.bool( True ),
maxFEDid = cms.untracked.int32( 779 ),
inputLabel = cms.InputTag( "rawDataCollector" ),
minFEDid = cms.untracked.int32( 770 ),
dataType = cms.string( "DDU" ),
readOutParameters = cms.PSet(
localDAQ = cms.untracked.bool( False ),
debug = cms.untracked.bool( False ),
rosParameters = cms.PSet(
localDAQ = cms.untracked.bool( False ),
debug = cms.untracked.bool( False ),
writeSC = cms.untracked.bool( True ),
readDDUIDfromDDU = cms.untracked.bool( True ),
readingDDU = cms.untracked.bool( True ),
performDataIntegrityMonitor = cms.untracked.bool( False )
),
performDataIntegrityMonitor = cms.untracked.bool( False )
),
dqmOnly = cms.bool( False )
)
return process
def neutronBG(process):
# common fragment allowing to simulate neutron background in muon system
if hasattr(process,'g4SimHits'):
# time window 10 second
TimeCut = cms.double(10000000000.0)
process.common_maximum_time.MaxTrackTime = TimeCut
process.common_maximum_time.DeadRegions = cms.vstring()
# Physics List XS
process.g4SimHits.Physics.type = cms.string('SimG4Core/Physics/FTFP_BERT_XS_EML')
process.g4SimHits.Physics.CutsOnProton = cms.untracked.bool(False)
process.g4SimHits.Physics.FlagFluo = cms.bool(True)
process.g4SimHits.Physics.ThermalNeutrons = cms.untracked.bool(False)
# Eta cut
process.g4SimHits.Generator.MinEtaCut = cms.double(-7.0)
process.g4SimHits.Generator.MaxEtaCut = cms.double(7.0)
# stacking action
process.g4SimHits.StackingAction.MaxTrackTime = TimeCut
process.g4SimHits.StackingAction.DeadRegions = cms.vstring()
process.g4SimHits.StackingAction.GammaThreshold = cms.double(0.0)
# stepping action
process.g4SimHits.SteppingAction.MaxTrackTime = TimeCut
process.g4SimHits.SteppingAction.DeadRegions = cms.vstring()
# Russian roulette disabled
process.g4SimHits.StackingAction.RusRoGammaEnergyLimit = cms.double(0.0)
process.g4SimHits.StackingAction.RusRoNeutronEnergyLimit = cms.double(0.0)
# Calorimeter hits
process.g4SimHits.CaloSD.TmaxHit = TimeCut
process.g4SimHits.CaloSD.TmaxHits = cms.vdouble(10000000000,10000000000,10000000000,10000000000,10000000000)
# full simulation of HF
process.g4SimHits.HCalSD.UseShowerLibrary = cms.bool(False)
process.g4SimHits.HFShower.UseShowerLibrary = cms.bool(False)
return(process)
def miniAOD_customizeMETFiltersFastSim(process):
"""Replace some MET filters that don't work in FastSim with trivial bools"""
for X in 'CSCTightHaloFilter', 'HBHENoiseFilter', 'HBHENoiseFilterResultProducer':
process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True)))
for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters':
process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False)))
return process
def addHLT(self,path,triggerProcess,summaryText = ''):
hltSkimmer = cms.EDFilter("HLTHighLevel",
TriggerResultsTag = cms.InputTag("TriggerResults","",triggerProcess),
HLTPaths = cms.vstring(path), # provide list of HLT paths (or patterns) you want
eventSetupPathsKey = cms.string(''), # not empty => use read paths from AlCaRecoTriggerBitsRcd via this key
andOr = cms.bool(True), # how to deal with multiple triggers: True (OR) accept if ANY is true, False (AND) accept if ALL are true
throw = cms.bool(True) # throw exception on unknown path names
)
pyModule = sys.modules[self.pyModuleName[0]]
if pyModule is None:
raise ValueError("'pyModuleName' Parameter invalid")
setattr(pyModule,'hltSkimmer',hltSkimmer)
self.sequence*=hltSkimmer
#now the counter
if summaryText is not '':
counter = cms.EDProducer("EventCounter")
counter.name=cms.string(summaryText)
counter.setLabel('hltSkimmerCounter')
pyModule = sys.modules[self.pyModuleName[0]]
if pyModule is None:
raise ValueError("'pyModuleName' Parameter invalid")
setattr(pyModule,'hltSkimmerCounter',counter)
self.sequence*=counter
def PileUpJetID(self) :
from RecoJets.JetProducers.PileupJetIDParams_cfi import full_53x, full_5x, cutbased
from RecoJets.JetProducers.PileupJetID_cfi import pileupJetIdProducer
full_53x.tmvaWeights = cms.string("RecoJets/JetProducers/data/TMVAClassificationCategory_JetID_53X_Dec2012.weights.xml")
full_53x.label = cms.string("full53x")
full_5x.label = cms.string("full5x")
JetCollection = "selectionsusycafak5pfjet" + ("Matched0" if not self.options.isData else "0")
self.process.puJetId = pileupJetIdProducer.clone(
produceJetIds = cms.bool(True),
jetids = cms.InputTag(""),
runMvas = cms.bool(False),
jets = cms.InputTag( JetCollection),
vertexes = cms.InputTag("offlinePrimaryVertices"),
algos = cms.VPSet(cutbased)
)
self.process.puJetMva = pileupJetIdProducer.clone(
produceJetIds = cms.bool(False),
jetids = cms.InputTag("puJetId"),
runMvas = cms.bool(True),
jets = cms.InputTag( JetCollection),
vertexes = cms.InputTag("offlinePrimaryVertices"),
algos = cms.VPSet(full_53x, full_5x)
)
return (self.process.puJetId * self.process.puJetMva )
def makeAnalysisStep(self, stepName, **inputs):
step = super(ElectronScaleFactors, self).makeAnalysisStep(stepName, **inputs)
if stepName == 'embedding' and self.isMC:
sfFile = path.join(UWVV_BASE_PATH, 'data', 'LeptonScaleFactors',
'eleSelectionSF_HZZ_Moriond17.root')
sfFileGap = path.join(UWVV_BASE_PATH, 'data', 'LeptonScaleFactors',
'eleSelectionSFGap_HZZ_Moriond17.root')
scaleFactorEmbedder = cms.EDProducer(
"PATElectronScaleFactorEmbedder",
src = step.getObjTag('e'),
fileName = cms.string(sfFile),
histName = cms.string('EGamma_SF2D'),
label = cms.string("effScaleFactor"),
xValue = cms.string('superCluster.eta'),
yValue = cms.string('pt'),
useError = cms.bool(True),
)
step.addModule('scaleFactorEmbedderE', scaleFactorEmbedder, 'e')
scaleFactorEmbedderGap = cms.EDProducer(
"PATElectronScaleFactorEmbedder",
src = step.getObjTag('e'),
fileName = cms.string(sfFileGap),
histName = cms.string('EGamma_SF2D'),
label = cms.string("effScaleFactorGap"),
xValue = cms.string('superCluster.eta'),
yValue = cms.string('pt'),
useError = cms.bool(True),
)
step.addModule('scaleFactorEmbedderEGap', scaleFactorEmbedderGap, 'e')
trkRecoSFFile = path.join(UWVV_BASE_PATH, 'data', 'LeptonScaleFactors',
'eleRecoSF_HZZ_Moriond17.root')
gsfTrackRecoScaleFactorEmbedder = cms.EDProducer(
"PATElectronScaleFactorEmbedder",
src = step.getObjTag('e'),
fileName = cms.string(trkRecoSFFile),
histName = cms.string('EGamma_SF2D'),
label = cms.string("trkRecoEffScaleFactor"),
xValue = cms.string('superCluster.eta'),
yValue = cms.string('pt'),
useError = cms.bool(True),
)
step.addModule('gsfTrackRecoScaleFactorEmbedder',
gsfTrackRecoScaleFactorEmbedder, 'e')
gsfTrackRecoExtraUncertaintyEmbedder = cms.EDProducer(
"PATElectronExpressionEmbedder",
src = step.getObjTag('e'),
labels = cms.untracked.vstring('trkRecoEffScaleFactorExtraError'),
functions = cms.untracked.vstring('? pt < 20. || pt > 75. ? 0.01 : 0.'),
)
step.addModule('gsfTrackRecoExtraUncertaintyEmbedder',
gsfTrackRecoExtraUncertaintyEmbedder, 'e')
return step
def psetMinPtCut():
return cms.PSet(
cutName = cms.string("MinPtCut"),
minPt = cms.double(5.0),
needsAdditionalProducts = cms.bool(False),
isIgnored = cms.bool(False)
)
def applyDefaultSelectionsPT(process):
#DONT CHANGE THOSE HERE:: THEY ARE NOT USED FOR YOUR SELECTIONS!!!
#ONLY FOR SYSTEMATICS . PLEASE CHANGE THEM in YOUR CFG FILE IF REALLY NEEDED
process.selectedPatTaus = cms.EDFilter("PATTauSelector",
src = cms.InputTag("cleanPatTaus"),
cut = cms.string('pt>15&&tauID("byLooseIsolationMVA")&&tauID("againstElectronLoose")&&tauID("againstMuonLoose")'),
filter = cms.bool(False)
)
process.selectedPatElectrons = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("cleanPatElectrons"),
cut = cms.string('pt>10&&userFloat("wp95")>0&&(userIso(0)+max(photonIso+neutralHadronIso()-0.5*userIso(2),0.0))/pt()<0.3'),
filter = cms.bool(False)
)
process.selectedPatMuons = cms.EDFilter("PATMuonSelector",
src = cms.InputTag("cleanPatMuons"),
cut = cms.string('pt>10&&userInt("tightID")&&(userIso(0)+max(photonIso+neutralHadronIso()-0.5*userIso(2),0.0))/pt()<0.3'),
filter = cms.bool(False)
)
process.cleanPatJets = cms.EDProducer("PATJetCleaner",
src = cms.InputTag("selectedPatJets"),
preselection = cms.string('abs(eta)<5.0&&userFloat("idLoose")>0&&pt>10&&userInt("fullIdLoose")>0'),
checkOverlaps = cms.PSet(),
finalCut = cms.string('')
)
process.selectedObjectsForSyst = cms.Sequence(process.selectedPatTaus+process.selectedPatElectrons+process.selectedPatMuons+process.cleanPatJets)
process.analysisSequence = cms.Sequence(process.analysisSequence*process.selectedObjectsForSyst)
def miniAOD_customizeMETFiltersFastSim(process):
"""Replace some MET filters that don't work in FastSim with trivial bools"""
for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','HcalStripHaloFilter','HBHENoiseFilter', 'HBHENoiseIsoFilter', 'HBHENoiseFilterResultProducer', 'chargedHadronTrackResolutionFilter', 'muonBadTrackFilter':
process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True)))
for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters':
process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False)))
return process
def calculateMetPhiCorrectedMET(process, prefix, conf, src):
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
if conf.isMC:
process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc
else:
process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data
selectedVerticesForMETCorr = process.selectedVerticesForMEtCorr.clone(
src=cms.InputTag("goodOfflinePrimaryVertices")
)
systShiftMETCorr = process.pfMEtSysShiftCorr.clone(
src=cms.InputTag(src), srcVertices=cms.InputTag(prep(prefix, "selectedVerticesForMETCorr"))
)
prod = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag(src),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(cms.InputTag(prep(prefix, "systShiftMETCorr"))),
type0Rsoft=cms.double(0.6),
applyType2Corrections=cms.bool(False),
srcCHSSums=cms.VInputTag(cms.InputTag("pfchsMETcorr", "type0")),
applyType0Corrections=cms.bool(False),
)
seq = cms.Sequence(selectedVerticesForMETCorr * systShiftMETCorr * prod)
sa(process, prefix, "systShiftMETCorr", systShiftMETCorr)
sa(process, prefix, "selectedVerticesForMETCorr", selectedVerticesForMETCorr)
sa(process, prefix, "phiCorrMETs", prod)
sa(process, prefix, "metPhiCorrSequence", seq)
return seq
def miniAOD_customizeMETFiltersFastSim(process):
"""Replace some MET filters that don't work in FastSim with trivial bools"""
for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter':
process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True)))
for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters':
process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False)))
return process
def addCrossSelector(self, obj, selection, name='', **otherObjects):
'''
Add a module to do a string cut and to do delta R cross-cleaning on
objects of type obj, and any other object collections. The keyword
arguments specify the other collections to clean with respect to, and
should be of the form obj:{'selection':'someSelection','deltaR':distance}.
So to clean objects that have pt<5 GeV or are within 0.4 of any 30+ GeV
slimmed jet, one would call this funtion like:
crossSelector('pt > 5.', j={'deltaR':0.4, 'selection':'pt>30','tag':'slimmedJets'})
If 'name' is empty, the module is called <obj>crossCleaning<stepName>.
'''
overlapParams = cms.PSet()
for obj2, params in otherObjects.iteritems():
objParams = cms.PSet(
src=self.getObjTag(obj2),
algorithm=cms.string('byDeltaR'),
preselection=cms.string(params.get('selection','')),
deltaR=cms.double(params.get('deltaR',0.3)),
checkRecoComponents=cms.bool(False),
pairCut=cms.string(''),
requireNoOverlaps=cms.bool(True),
)
setattr(overlapParams, getObjName(obj2), objParams)
mod = cms.EDProducer(
"PAT{}Cleaner".format(getObjName(obj.split('_')[0], True)),
src=self.getObjTag(obj),
preselection=cms.string(selection),
checkOverlaps = overlapParams,
finalCut = cms.string(''),
)
self.addModule(''.join([obj, name if name else 'crossCleaning',
self.name]).replace('_',''), mod, obj)
def addTriggerMatchingForLeptons(process, postfix='') :
# define the trigger matchers
process.muTriggerMatchPF = cms.EDProducer( "PATTriggerMatcherDRLessByR",
src = cms.InputTag( "selectedPatMuons"+postfix ),
matched = cms.InputTag( "patTrigger" ),
matchedCuts = cms.string( 'type( "TriggerMuon" ) && ( path("HLT_Mu8_*") || path("HLT_Mu12_*") || path("HLT_Mu13_Mu8_*") || path("HLT_DoubleMu7_*" || path("HLT_Mu17_Mu8_*)' ),
maxDPtRel = cms.double( 0.5 ), # no effect here
maxDeltaR = cms.double( 0.5 ),
maxDeltaEta = cms.double( 0.2 ), # no effect here
# definition of matcher output
resolveAmbiguities = cms.bool( False ),
resolveByMatchQuality = cms.bool( False )
)
process.eleTriggerMatchPF = cms.EDProducer( "PATTriggerMatcherDRLessByR",
src = cms.InputTag( "selectedPatElectrons"+postfix ),
matched = cms.InputTag( "patTrigger" ),
#matchedCuts = cms.string( 'type( "TriggerL1NoIsoEG" ) || type( "TriggerL1IsoEG" ) || type( "TriggerElectron" )' ),
matchedCuts = cms.string( 'type( "TriggerElectron" )' ),
maxDPtRel = cms.double( 0.5 ), # no effect here
maxDeltaR = cms.double( 0.5 ),
maxDeltaEta = cms.double( 0.2 ), # no effect here
# definition of matcher output
resolveAmbiguities = cms.bool( False ),
resolveByMatchQuality = cms.bool( False )
)
from PhysicsTools.PatAlgos.tools.coreTools import removeCleaning
removeCleaning( process )
setattr( process, 'muTriggerMatch' + postfix, process.muTriggerMatchPF )
setattr( process, 'eleTriggerMatch' + postfix, process.eleTriggerMatchPF )
switchOnTriggerMatching( process, triggerMatchers = [ 'muTriggerMatchPFlow','eleTriggerMatchPFlow' ], sequence = 'patPF2PATSequence' + postfix )
removeCleaningFromTriggerMatching( process, sequence = 'patPF2PATSequence' + postfix )
def addCategory(pset,label,cutbased=None,subcats=0,variables=[],histograms=[],mvas=None,classname=None,binnedOnly=None,
dumpPdfWeights=None,nPdfWeights=None,nAlphaSWeights=None,nScaleWeights=None,splitPdfByStage0Cat=None):
if subcats >= 0:
catDef = cms.PSet(label=cms.string(label),
subcats=cms.int32(subcats),
variables=cms.VPSet(),
histograms=cms.VPSet(),
)
if classname: catDef.className=cms.string(classname)
if binnedOnly: catDef.binnedOnly=cms.bool(binnedOnly)
if dumpPdfWeights: catDef.dumpPdfWeights=cms.bool(dumpPdfWeights)
if nPdfWeights: catDef.nPdfWeights=cms.int32(nPdfWeights)
if nAlphaSWeights: catDef.nAlphaSWeights=cms.int32(nAlphaSWeights)
if nScaleWeights: catDef.nScaleWeights=cms.int32(nScaleWeights)
if splitPdfByStage0Cat is not None: catDef.splitPdfByStage0Cat=cms.bool(splitPdfByStage0Cat)
addVariables( catDef.variables, variables )
addHistograms( catDef.histograms, histograms )
if mvas:
catDef.mvas = cms.VPSet()
addMVAs( catDef.mvas, mvas )
pset.categories.append(catDef)
if cutbased:
cb = cms.PSet( cut=cms.string(cutbased) )
if( label != "" or classname):
cb.name = cms.untracked.string(label)
pset.classifierCfg.categories.append(cb)
def switchToAOD(process, triggerHistManager = None, eventDumpPlugin = None):
# call "standard" PAT function to restrict all InputTags to AOD event content
restrictInputToAOD(process, [ "All", ])
# switch collection of ECAL recHits used as input for IsoDeposit computation
# from list of all ECAL recHits in the event to "reduced" collections
# limited to cones of size dR = 0.6 around electron candidates
if hasattr(process, "p"):
massSearchReplaceAnyInputTag(process.p, cms.InputTag("ecalRecHit", "EcalRecHitsEB"), cms.InputTag("reducedEcalRecHitsEB"))
massSearchReplaceAnyInputTag(process.p, cms.InputTag("ecalRecHit", "EcalRecHitsEE"), cms.InputTag("reducedEcalRecHitsEE"))
# disable PAT trigger matching
# (not yet implemented for photons and jets)
if hasattr(process, "patTriggerSequence"):
process.patDefaultSequence.remove(process.patTriggerSequence)
process.patElectrons.embedHighLevelSelection = cms.bool(False)
#process.patPhotons.embedHighLevelSelection = cms.bool(False)
process.patMuons.embedHighLevelSelection = cms.bool(False)
process.patTaus.embedHighLevelSelection = cms.bool(False)
#process.patJets.embedHighLevelSelection = cms.bool(False)
process.patMETs.embedHighLevelSelection = cms.bool(False)
if hasattr(process, "patPFMETs"):
process.patPFMETs.embedHighLevelSelection = cms.bool(False)
if triggerHistManager is not None:
triggerHistManager.hltResultsSource = cms.InputTag('')
triggerHistManager.l1Bits = cms.vstring()
triggerHistManager.hltPaths = cms.vstring()
if eventDumpPlugin is not None:
eventDumpPlugin.l1GtReadoutRecordSource = cms.InputTag('')
eventDumpPlugin.l1GtObjectMapRecordSource = cms.InputTag('')
eventDumpPlugin.hltResultsSource = cms.InputTag('')
def customiseCommonHI(process):
###############################################################################################
####
#### Top level replaces for handling strange scenarios of early HI collisions
####
## Offline Silicon Tracker Zero Suppression
process.siStripZeroSuppression.Algorithms.PedestalSubtractionFedMode = cms.bool(False)
process.siStripZeroSuppression.Algorithms.CommonModeNoiseSubtractionMode = cms.string("IteratedMedian")
process.siStripZeroSuppression.doAPVRestore = cms.bool(True)
process.siStripZeroSuppression.storeCM = cms.bool(True)
## Fixes to protect against large BS displacements
process.hiPixel3ProtoTracks.RegionFactoryPSet.RegionPSet.originRadius = 0.2
process.hiPixel3ProtoTracks.RegionFactoryPSet.RegionPSet.fixedError = 0.5
process.hiSelectedProtoTracks.maxD0Significance = 100
process.hiPixelAdaptiveVertex.TkFilterParameters.maxD0Significance = 100
process.hiPixelAdaptiveVertex.useBeamConstraint = False
process.hiPixelAdaptiveVertex.PVSelParameters.maxDistanceToBeam = 1.0
###
### end of top level replacements
###
###############################################################################################
return process
def customiseForQuadrupletsByPropagation(process):
for module in process._Process__producers.values():
if not hasattr(module, "SeedMergerPSet"):
continue
# Adjust seeding layers
seedingLayersName = module.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel()
seedingLayersModule = getattr(process, seedingLayersName)
seedingLayersModule.layerList = process.PixelSeedMergerQuadruplets.layerList.value()
# Configure seed generator / pixel track producer
del module.SeedMergerPSet
triplets = module.OrderedHitsFactoryPSet.clone()
module.OrderedHitsFactoryPSet = cms.PSet(
ComponentName = cms.string("CombinedHitQuadrupletGenerator"),
GeneratorPSet = cms.PSet(
ComponentName = cms.string("PixelQuadrupletGenerator"),
extraHitRZtolerance = triplets.GeneratorPSet.extraHitRZtolerance,
extraHitRPhitolerance = triplets.GeneratorPSet.extraHitRPhitolerance,
maxChi2 = cms.double(50),
keepTriplets = cms.bool(True)
),
TripletGeneratorPSet = triplets.GeneratorPSet,
SeedingLayers = cms.InputTag(seedingLayersName),
)
if hasattr(triplets.GeneratorPSet, "SeedComparitorPSet"):
module.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = triplets.GeneratorPSet.SeedComparitorPSet
if module.type_() == "PixelTrackProducer":
module.CleanerPSet.useQuadrupletAlgo = cms.bool(True)
return process
def embedTracksInTaus( process, postfix, enable):
print "Embedding tracks in paTaus: "
print enable
patTaus = getattr(process,'patTaus'+postfix)
patTaus.embedLeadTrack = cms.bool(enable)
patTaus.embedSignalTracks = cms.bool(enable)
patTaus.embedIsolationTracks = cms.bool(enable)
def customise(process):
# fragment allowing to simulate neutron background in muon system
if hasattr(process,'g4SimHits'):
# time window 100 millisecond
process.common_maximum_time.MaxTrackTime = cms.double(100000000.0)
process.common_maximum_time.DeadRegions = cms.vstring()
# Physics List HP
process.g4SimHits.Physics.type = cms.string('SimG4Core/Physics/FTFP_BERT_HP_EML')
process.g4SimHits.Physics.CutsOnProton = cms.untracked.bool(False)
process.g4SimHits.Physics.FlagMuNucl = cms.bool(True)
process.g4SimHits.Physics.FlagFluo = cms.bool(True)
# Eta cut
process.g4SimHits.Generator.MinEtaCut = cms.double(-7.0)
process.g4SimHits.Generator.MaxEtaCut = cms.double(7.0)
# stacking action
process.g4SimHits.StackingAction.MaxTrackTime = cms.double(100000000.0)
process.g4SimHits.StackingAction.DeadRegions = cms.vstring()
process.g4SimHits.StackingAction.KillHeavy = cms.bool(True)
process.g4SimHits.StackingAction.IonThreshold = cms.double(0.001)
process.g4SimHits.StackingAction.ProtonThreshold = cms.double(0.001)
process.g4SimHits.StackingAction.NeutronThreshold = cms.double(0.0)
process.g4SimHits.StackingAction.GammaThreshold = cms.double(0.0005)
# stepping action
process.g4SimHits.SteppingAction.MaxTrackTime = cms.double(100000000.0)
process.g4SimHits.SteppingAction.DeadRegions = cms.vstring()
# Russian roulette disabled
process.g4SimHits.StackingAction.RusRoGammaEnergyLimit = cms.double(0.0)
process.g4SimHits.StackingAction.RusRoNeutronEnergyLimit = cms.double(0.0)
# full simulation of HF
process.g4SimHits.HFShower.UseHFGflash = cms.bool(False)
return(process)
def customise_csc_Packer(process):
"""Use 2013 a.k.a. post-LS1 version
"""
process.cscpacker.useFormatVersion = cms.uint32(2013)
process.cscpacker.usePreTriggers = cms.bool(False)
process.cscpacker.packEverything = cms.bool(True)
return process
def addZMassHistos(self):
from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons
zMassMuons = self.analysis.addAnalysisModule(
"ZMassMuons",
selector = cleanPatMuons.clone(
#preselection = cms.string(zMassVetoMuons),
src = muons,
checkOverlaps = cms.PSet(
muons = cms.PSet(
src = self.selectedMuons,
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True)
)
)
),
counter=False).getSelectorInputTag()
self.zmumu = self.analysis.addProducer("ZMuMu", self.candCombinerPrototype.clone(decay = cms.string(self.selectedMuons.getModuleLabel()+" "+zMassMuons.getModuleLabel())))
self.cloneHistoAnalyzer("ZMuMuCands")
self.histoAnalyzer.zmumu_ = cms.untracked.PSet(src = self.zmumu, histograms = cms.VPSet(histoZMass.pset()))
self.cloneMultipAnalyzer(name="MultiplicityZMuMuCands")
self.multipAnalyzer.zMassMuons = self.multipAnalyzer.selMuons.clone(src = zMassMuons)
def customise(process):
# Turn off zero suppression in Ecal:
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("EcalSRSettingsRcd"),
tag = cms.string('EcalSRSettings_fullreadout_v01_mc'),
connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_34X_ECAL")
))
# Turn off noise generation:
process.mix.digitizers.hcal.doNoise = cms.bool(False)
process.mix.digitizers.hcal.doEmpty = False
process.mix.digitizers.hcal.doHPDNoise = False
process.mix.digitizers.hcal.doIonFeedback = False
process.mix.digitizers.hcal.doThermalNoise = False
process.mix.digitizers.ecal.doNoise = cms.bool(False)
process.mix.digitizers.pixel.AddNoise = cms.bool(False)
process.mix.digitizers.strip.AddNoise = cms.bool(False)
process.simMuonCSCDigis.strips.doNoise = False
process.simMuonCSCDigis.wires.doNoise = False
process.simMuonDTDigis.onlyMuHits = True
process.simMuonRPCDigis.Noise = False
# Turn off zero suppression in Hcal:
process.simHcalDigis.HBlevel = -10000
process.simHcalDigis.HElevel = -10000
process.simHcalDigis.HOlevel = -10000
process.simHcalDigis.HFlevel = -10000
process.simHcalDigis.useConfigZSvalues = 1
return(process)
def customiseDataRun2Common(process):
if hasattr(process,'CSCGeometryESModule'):
process.CSCGeometryESModule.useGangedStripsInME1a = cms.bool(False)
if hasattr(process,'CSCIndexerESProducer'):
process.CSCIndexerESProducer.AlgoName=cms.string("CSCIndexerPostls1")
if hasattr(process,'CSCChannelMapperESProducer'):
process.CSCChannelMapperESProducer.AlgoName=cms.string("CSCChannelMapperPostls1")
if hasattr(process,'csc2DRecHits'):
process.csc2DRecHits.readBadChannels = cms.bool(False)
process.csc2DRecHits.CSCUseGasGainCorrections = cms.bool(False)
if hasattr(process,'valCscTriggerPrimitiveDigis'):
#this is not doing anything at the moment
process.valCscTriggerPrimitiveDigis.commonParam.gangedME1a = cms.bool(False)
if hasattr(process,'valCsctfTrackDigis'):
process.valCsctfTrackDigis.gangedME1a = cms.untracked.bool(False)
from SLHCUpgradeSimulations.Configuration.postLS1Customs import customise_Reco,customise_RawToDigi,customise_DQM
if hasattr(process,'RawToDigi'):
process=customise_RawToDigi(process)
if hasattr(process,'reconstruction'):
process=customise_Reco(process)
if hasattr(process,'dqmoffline_step'):
process=customise_DQM(process)
return process
def MakeEventSelection( invMassMethod, _from, _to, GenMatch, _JetVeto, _VetoMoreThan2, _MET, _MT) :
method = -1
if invMassMethod == "Momentum" :
method = 0
elif invMassMethod == "GSF" :
method = 1
elif invMassMethod == "GSFOut" :
method = 2
elif invMassMethod == "SC" :
method = 3
elif invMassMethod == "Seed" :
method = 4
elif invMassMethod == "CTF" :
method = 5
ret = cms.PSet(
InvMassMethod=cms.int32(method),
InvMassMin=cms.double(_from),
InvMassMax=cms.double(_to),
MET=cms.double(_MET),
MT=cms.double(_MT),
ElectronsShouldMatch=cms.bool(GenMatch),
JetVeto=cms.bool(_JetVeto),
VetoMoreThan2Elecs=cms.bool(_VetoMoreThan2)
)
return ret
def getTreeInfo(nickname, globaltag, kappaTag):
sample = get_sample_by_nick(nickname)
dict = database
sample_details = dict[sample]
pd_name, details, filetype = sample.strip("/").split("/")
centerOfMassEnergy = int(sample_details["energy"])
data = sample_details["data"]
isEmbedded = sample_details["embedded"]
miniaod = (sample_details["format"] == "MINIAODSIM" or sample_details["format"] == "MINIAOD")
return data, isEmbedded, miniaod, cms.PSet(
dataset = cms.string(str(sample)),
generator = cms.string(str(sample_details["generator"])),
productionProcess = cms.string(str(sample_details["process"])),
globalTag = cms.string(globaltag),
scenario = cms.string(str(sample_details["scenario"])),
campaign = cms.string(str(sample_details["campaign"])),
kappaTag = cms.string(kappaTag),
isEmbedded = cms.bool(isEmbedded),
centerOfMassEnergy = cms.int32(centerOfMassEnergy),
isData = cms.bool(data)
)
def addMuonJetSelection(process, sequence, prefix="muonSelectionJetSelection"):
selector = prefix+"GoodJets"
filter = prefix+"Filter"
counter = prefix
import muonSelectionPF_cff as muonSelection
from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets
m1 = cleanPatJets.clone(
# src = "selectedPatJets",
src = "goodJets", # we should use the pat::Jets constructed in the
preselection = cms.string(jetSelection),
checkOverlaps = cms.PSet(
muons = cms.PSet(
src = cms.InputTag(tauEmbeddingMuons),
algorithm = cms.string("byDeltaR"),
preselection = cms.string(""),
deltaR = cms.double(0.1),
checkRecoComponents = cms.bool(False),
pairCut = cms.string(""),
requireNoOverlaps = cms.bool(True),
)
)
)
m2 = muonSelection.goodJetFilter.clone(src=selector, minNumber=3)
m3 = cms.EDProducer("EventCountProducer")
setattr(process, selector, m1)
setattr(process, filter, m2)
setattr(process, counter, m3)
sequence *= (m1 * m2 * m3)
return [counter]
def makePuppiesFromMiniAOD( process, createScheduledSequence=False ):
task = getPatAlgosToolsTask(process)
process.load('CommonTools.PileupAlgos.Puppi_cff')
task.add(process.puppi)
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.clonePackedCands = cms.bool(True)
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.puppi.useExistingWeights = cms.bool(True)
process.pfNoLepPUPPI = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 && abs(pdgId) != 15"))
task.add(process.pfNoLepPUPPI)
process.pfLeptonsPUPPET = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) == 13 || abs(pdgId) == 11 || abs(pdgId) == 15"))
task.add(process.pfLeptonsPUPPET)
addToProcessAndTask('puppiNoLep', process.puppi.clone(), process, task)
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiNoLep.useWeightsNoLep = cms.bool(True)
process.puppiNoLep.useExistingWeights = cms.bool(True)
process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))
task.add(process.puppiMerged)
process.load('CommonTools.PileupAlgos.PhotonPuppi_cff')
task.add(process.puppiPhoton)
addToProcessAndTask('puppiForMET', process.puppiPhoton.clone(), process, task)
process.puppiForMET.candName = cms.InputTag('packedPFCandidates')
process.puppiForMET.photonName = cms.InputTag('slimmedPhotons')
process.puppiForMET.runOnMiniAOD = cms.bool(True)
setupPuppiPhotonMiniAOD(process)
task.add(process.egmPhotonIDTask)
#Line below replaces reference linking wiht delta R matching because the puppi references after merging are not consistent with those of the original packed candidate collection
process.puppiForMET.useRefs = False
#Line below points puppi MET to puppi no lepton which increases the response
process.puppiForMET.puppiCandName = 'puppiMerged'
#making a sequence for people running the MET tool in scheduled mode
if createScheduledSequence:
puppiMETSequence = cms.Sequence(process.puppi*process.pfLeptonsPUPPET*process.pfNoLepPUPPI*process.puppiNoLep*process.puppiMerged*process.puppiForMET)
setattr(process, "puppiMETSequence", puppiMETSequence)
def customiseFor21664_forMahiOnM2only(process):
for producer in producers_by_type(process, "HBHEPhase1Reconstructor"):
if (producer.algorithm.useM2 == cms.bool(True)):
producer.algorithm.useMahi = cms.bool(True)
producer.algorithm.useM2 = cms.bool(False)
producer.algorithm.useM3 = cms.bool(False)
return process
# Copied from https://github.com/cms-sw/genproductions for RelVal June 5, 2014
import FWCore.ParameterSet.Config as cms
from GeneratorInterface.ExternalDecays.TauolaSettings_cff import *
from Configuration.Generator.Pythia8CommonSettings_cfi import *
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *
generator = cms.EDFilter(
"Pythia8HadronizerFilter",
ExternalDecays=cms.PSet(Tauola=cms.untracked.PSet(
UseTauolaPolarization=cms.bool(True),
InputCards=cms.PSet(mdtau=cms.int32(0),
pjak2=cms.int32(3),
pjak1=cms.int32(3))),
parameterSets=cms.vstring('Tauola')),
UseExternalGenerators=cms.untracked.bool(True),
maxEventsToPrint=cms.untracked.int32(1),
pythiaPylistVerbosity=cms.untracked.int32(1),
filterEfficiency=cms.untracked.double(1.0),
pythiaHepMCVerbosity=cms.untracked.bool(False),
comEnergy=cms.double(13000.),
jetMatching=cms.untracked.PSet(
scheme=cms.string("Madgraph"),
mode=cms.string("auto"), # soup, or "inclusive" / "exclusive"
MEMAIN_etaclmax=cms.double(-1),
MEMAIN_qcut=cms.double(-1),
MEMAIN_minjets=cms.int32(-1),
MEMAIN_maxjets=cms.int32(-1),
MEMAIN_showerkt=cms.double(
0), # use 1=yes only for pt-ordered showers !
MEMAIN_nqmatch=cms.int32(
import FWCore.ParameterSet.Config as cms
import HLTrigger.HLTfilters.hltHighLevel_cfi
ALCARECORandomFromRECOHLT = HLTrigger.HLTfilters.hltHighLevel_cfi.hltHighLevel.clone(
HLTPaths=cms.vstring("*Random*"),
eventSetupPathsKey='',
TriggerResultsTag=cms.InputTag("TriggerResults", "", "HLT"),
andOr=cms.bool(True), # choose logical OR between Triggerbits
throw=cms.bool(False) # tolerate triggers stated above, but not available
)
from Calibration.LumiAlCaRecoProducers.alcaPCCProducer_cfi import alcaPCCProducer
alcaPCCProducerRandomFromRECO = alcaPCCProducer.clone()
alcaPCCProducerRandomFromRECO.pixelClusterLabel = cms.InputTag(
"siPixelClusters")
alcaPCCProducerRandomFromRECO.trigstring = cms.untracked.string(
"alcaPCCRandomFromRECO")
# Sequence #
seqALCARECOAlCaPCCRandomFromRECO = cms.Sequence(ALCARECORandomFromRECOHLT +
alcaPCCProducerRandomFromRECO)
# do trigger matching for muons
triggerProcessName = 'HLT'
process.cleanMuonTriggerMatchHLT0 = cms.EDProducer(
# match by DeltaR only (best match by DeltaR)
'PATTriggerMatcherDRLessByR',
src=cms.InputTag('cleanPatMuons'),
# default producer label as defined in
# PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
matched=cms.InputTag('patTrigger'),
#matchedCuts = cms.string('path("HLT_DoubleMu3p5_LowMass_Displaced*",0,0)'),
matchedCuts=cms.string(
'path("HLT_DoubleMu4_LowMassNonResonantTrk_Displaced*",0,0)'),
maxDeltaR=cms.double(0.1),
# only one match per trigger object
resolveAmbiguities=cms.bool(True),
# take best match found per reco object (by DeltaR here, see above)
resolveByMatchQuality=cms.bool(False))
from PhysicsTools.PatAlgos.tools.trigTools import *
switchOnTriggerMatchEmbedding(process,
triggerMatchers=['cleanMuonTriggerMatchHLT0'],
hltProcess=triggerProcessName,
outputModule='')
g_TriggerNames_LastFilterNames = [
#('HLT_DoubleMu3p5_LowMass_Displaced', 'hltDisplacedmumuFilterDoubleMu3p5LowMass')
('HLT_DoubleMu4_LowMassNonResonantTrk_Displaced',
'hltLowMassNonResonantTkVertexFilter')
]
matching.cscSimHit.minNHitsChamber = 3 matching.cscStripDigi.minNHitsChamber = 3 matching.cscWireDigi.minNHitsChamber = 3 matching.cscCLCT.minNHitsChamber = 3 matching.cscALCT.minNHitsChamber = 3 matching.cscLCT.minNHitsChamber = 3 matching.cscLCT.matchAlctGem = True matching.cscMPLCT.minNHitsChamber = 3 process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) process.p = cms.Path(process.GEMCSCAnalyzer) mat = process.GEMCSCAnalyzer.simTrackMatching mat.simTrack.minEta = cms.double(1.4) mat.me0Segment.run = cms.bool(False) mat.me0Muon.run = cms.bool(False) mat.me0SimHit.run = cms.bool(False) mat.me0SimHit.simMuOnly = cms.bool(False) mat.me0RecHit.run = cms.bool(False) ## messages print print 'Input files:' print '----------------------------------------' print process.source.fileNames print print 'Output file:' print '----------------------------------------' print process.TFileService.fileName
HFdepthTwoParameterA = cms.vdouble(0.002861, 0.004168, 0.0064, 0.008388, 0.011601,
0.014425, 0.018633, 0.023232, 0.028274, 0.035447,
0.051579, 0.086593),
HFdepthTwoParameterB = cms.vdouble(-2e-06, -0.0, -7e-06, -6e-06, -2e-06,
1e-06, 1.9e-05, 3.1e-05, 6.7e-05, 1.2e-05,
0.000157, -3e-06)
)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(500)
)
process.FedChannelDigis = cms.EDProducer("SiStripRawToDigiModule",
AppendedBytes = cms.int32(0),
CreateDigis = cms.untracked.bool(True),
DoAPVEmulatorCheck = cms.bool(False),
DoAllCorruptBufferChecks = cms.bool(False),
ErrorThreshold = cms.uint32(7174),
LegacyUnpacker = cms.bool(False),
MarkModulesOnMissingFeds = cms.bool(True),
ProductLabel = cms.InputTag("rawDataCollector"),
TriggerFedId = cms.int32(-1),
UnpackBadChannels = cms.bool(True),
UnpackCommonModeValues = cms.bool(False),
UseDaqRegister = cms.bool(True),
UseFedKey = cms.bool(True)
)
process.CommissioningHistos = cms.EDAnalyzer("SiStripCommissioningSource",
CommissioningTask = cms.untracked.string('PEDESTALS'),
import FWCore.ParameterSet.Config as cms
from Configuration.Generator.PyquenDefaultSettings_cff import *
from Configuration.Generator.PythiaUEZ2Settings_cfi import *
hiSignal = cms.EDFilter("PyquenGeneratorFilter",
collisionParameters,
qgpParameters,
pyquenParameters,
doQuench = cms.bool(False),
cFlag = cms.int32(0), ## centrality flag
bMin = cms.double(0.0), ## min impact param (fm); valid only if cflag_!=0
bMax = cms.double(0.0), ## max impact param (fm); valid only if cflag_!=0
bFixed = cms.double(0.0), ## fixed impact param (fm); valid only if cflag_=0
filterType = cms.untracked.string('EcalGenEvtSelector'),
partons = cms.vint32(1, 2, 3, 4, 5, 6, #quarks
21, 22), #gluon, photon
partonPt = cms.vdouble(0, 0, 0, 0, 0, 0,
0, 0),
partonStatus = cms.vint32(2, 2, 2, 2, 2, 2,
2, 1),
particles = cms.vint32(221, #eta
331, #eta'
223, #omega
111), #pi0
particlePt = cms.vdouble(35, 35, 35, 35),
particleStatus = cms.vint32(2, #eta
2, #eta'
2, #omega
),
comEnergy=cms.double(13000.0),
crossSection=cms.untracked.double(0.0284),
filterEfficiency=cms.untracked.double(-1),
hscpFlavor=cms.untracked.string('stau'),
massPoint=cms.untracked.int32(700),
maxEventsToPrint=cms.untracked.int32(0),
particleFile=cms.untracked.string(
'DisappTrks/SignalMC/data/geant4/geant4_AMSB_chargino_700GeV_ctau10000cm.slha'
),
processFile=cms.untracked.string(
'SimG4Core/CustomPhysics/data/RhadronProcessList.txt'),
pythiaHepMCVerbosity=cms.untracked.bool(False),
pythiaPylistVerbosity=cms.untracked.int32(0),
slhaFile=cms.untracked.string(''),
useregge=cms.bool(False))
process.ProductionFilterSequence = cms.Sequence(process.generator)
# Path and EndPath definitions
process.generation_step = cms.Path(process.pgen)
process.simulation_step = cms.Path(process.psim)
process.genfiltersummary_step = cms.EndPath(process.genFilterSummary)
process.endjob_step = cms.EndPath(process.endOfProcess)
process.RAWSIMoutput_step = cms.EndPath(process.RAWSIMoutput)
# Schedule definition
process.schedule = cms.Schedule(process.generation_step,
process.genfiltersummary_step,
process.simulation_step, process.endjob_step,
process.RAWSIMoutput_step)
import FWCore.ParameterSet.Config as cms
# Pat
from PhysicsTools.PatAlgos.patHeavyIonSequences_cff import *
# Photons
makeHeavyIonPhotons.remove(interestingTrackEcalDetIds)
photonMatch.matched = cms.InputTag("hiGenParticles")
patPhotons.addPhotonID = cms.bool(False)
makeHeavyIonPhotons *= selectedPatPhotons
# Jets
patJets.jetSource = cms.InputTag("iterativeConePu5CaloJets")
patJets.addBTagInfo = False
patJets.addTagInfos = False
patJets.addDiscriminators = False
patJets.addAssociatedTracks = False
patJets.addJetCharge = False
patJets.addJetID = True
patJets.getJetMCFlavour = False
patJets.addGenPartonMatch = True
patJets.addGenJetMatch = True
patJets.embedGenJetMatch = True
patJets.embedGenPartonMatch = True
# # cut = cms.vstring('pt > 20.0 & abs(eta) < 3.0'),
# cut = cms.vstring(''),
# selector = cms.string('patMuonSEventSelector')
# # selector = cms.string('')
# )#,
# # leadingElectron = cms.PSet(
# # src = cms.string('electrons'),
# # cut = cms.vstring('pt > 20.0 & abs(eta) < 3.0'),
# # selector = cms.string('patElectronSEventSelector')
# # )
),
selections=cms.PSet(
minSelection=cms.PSet(
# #vstring filterOrder = { "leadingElectron" }
filterOrder=cms.vstring('none'),
makeFinalPlots=cms.bool(False),
makeSummaryTable=cms.bool(True),
makeContentPlots=cms.bool(False),
makeAllButOnePlots=cms.bool(False),
ntuplize=cms.bool(True),
nMonitor=cms.uint32(1000),
makeCumulativePlots=cms.bool(False)), ),
),
Plotter=cms.PSet(),
# TH1s = cms.PSet(
# ),
# ComponentName = cms.string('VariablePlotter'),
# TProfiles = cms.PSet(
# ),
process.source = cms.Source ("PoolSource",
fileNames = cms.untracked.vstring ("file:WR_2400_ToLNu_MASSNR_MiniAOD_MuMuJJ.root")
,
)
process.options = cms.untracked.PSet(
SkipEvent = cms.untracked.vstring('ProductNotFound')
)
process.TFileService = cms.Service("TFileService",
fileName = cms.string("WR_2400_ToLNu_240_Analysis_MuMuJJ.root")
)
process.badGlobalMuonTagger = cms.EDFilter("BadGlobalMuonTagger",
muons = cms.InputTag("slimmedMuons"),
vtx = cms.InputTag("offlineSlimmedPrimaryVertices"),
muonPtCut = cms.double(20),
selectClones = cms.bool(False),
taggingMode = cms.bool(True),
verbose = cms.untracked.bool(False)
)
process.cloneGlobalMuonTagger = process.badGlobalMuonTagger.clone(
selectClones = cms.bool(True)
)
process.removeBadAndCloneGlobalMuons = cms.EDProducer("MuonRefPruner",
input = cms.InputTag("slimmedMuons"),
toremove = cms.InputTag("badGlobalMuonTagger", "bad"),
toremove2 = cms.InputTag("cloneGlobalMuonTagger", "bad")
)
process.tunePMuons = cms.EDProducer("TunePMuonProducer",
src = cms.InputTag("removeBadAndCloneGlobalMuons")
import FWCore.ParameterSet.Config as cms
# configuration to model pileup for initial physics phase
from SimGeneral.MixingModule.mixObjects_cfi import theMixObjects
from SimGeneral.MixingModule.mixPoolSource_cfi import *
from SimGeneral.MixingModule.digitizers_cfi import *
mix = cms.EDProducer(
"MixingModule",
digitizers=cms.PSet(theDigitizers),
LabelPlayback=cms.string(''),
maxBunch=cms.int32(0),
minBunch=cms.int32(0), ## in terms of 25 nsec
bunchspace=cms.int32(50), ##ns
mixProdStep1=cms.bool(False),
mixProdStep2=cms.bool(False),
playback=cms.untracked.bool(False),
useCurrentProcessOnly=cms.bool(False),
input=cms.SecSource(
"EmbeddedRootSource",
type=cms.string('probFunction'),
nbPileupEvents=cms.PSet(
probFunctionVariable=cms.vint32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24),
probValue=cms.vdouble(0.0698146584, 0.0698146584, 0.0698146584,
0.0698146584, 0.0698146584, 0.0698146584,
0.0698146584, 0.0698146584, 0.0698146584,
0.0698146584, 0.0698146584, 0.0630151648,
0.0526654164, 0.0402754482, 0.0292988928,
0.0194384503, 0.0122016783, 0.007207042,
import FWCore.ParameterSet.Config as cms
from HeavyIonsAnalysis.JetAnalysis.patHeavyIonSequences_cff import patJetGenJetMatch, patJetPartonMatch, patJetCorrFactors, patJets
from HeavyIonsAnalysis.JetAnalysis.inclusiveJetAnalyzer_cff import *
from HeavyIonsAnalysis.JetAnalysis.bTaggers_cff import *
from RecoJets.JetProducers.JetIDParams_cfi import *
from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness
akPu4PFmatch = patJetGenJetMatch.clone(
src = cms.InputTag("akPu4PFJets"),
matched = cms.InputTag("ak4HiCleanedGenJets"),
resolveByMatchQuality = cms.bool(False),
maxDeltaR = 0.4
)
akPu4PFmatchGroomed = patJetGenJetMatch.clone(
src = cms.InputTag("ak4HiGenJets"),
matched = cms.InputTag("ak4HiCleanedGenJets"),
resolveByMatchQuality = cms.bool(False),
maxDeltaR = 0.4
)
akPu4PFparton = patJetPartonMatch.clone(src = cms.InputTag("akPu4PFJets")
)
akPu4PFcorr = patJetCorrFactors.clone(
useNPV = cms.bool(False),
useRho = cms.bool(False),
# primaryVertices = cms.InputTag("hiSelectedVertex"),
levels = cms.vstring('L2Relative','L3Absolute'),
import FWCore.ParameterSet.Config as cms
# This config was generated automatically using generate2026Geometry.py
# If you notice a mistake, please update the generating script, not just this config
from Configuration.Geometry.GeometryDD4hepExtended2026D85_cff import *
# tracker
from Geometry.CommonTopologies.globalTrackingGeometry_cfi import *
from RecoTracker.GeometryESProducer.TrackerRecoGeometryESProducer_cfi import *
from Geometry.TrackerGeometryBuilder.TrackerAdditionalParametersPerDet_cfi import *
from Geometry.TrackerGeometryBuilder.trackerParameters_cff import *
from Geometry.TrackerNumberingBuilder.trackerTopology_cfi import *
from Geometry.TrackerGeometryBuilder.idealForDigiTrackerGeometry_cff import *
trackerGeometry.applyAlignment = cms.bool(False)
# calo
from Geometry.CaloEventSetup.HGCalV9Topology_cfi import *
from Geometry.HGCalGeometry.HGCalGeometryESProducer_cfi import *
from Geometry.CaloEventSetup.CaloTopology_cfi import *
from Geometry.CaloEventSetup.CaloGeometryBuilder_cfi import *
CaloGeometryBuilder = cms.ESProducer(
"CaloGeometryBuilder",
SelectedCalos=cms.vstring("HCAL", "ZDC", "EcalBarrel", "TOWER",
"HGCalEESensitive", "HGCalHESiliconSensitive",
"HGCalHEScintillatorSensitive"))
from Geometry.EcalAlgo.EcalBarrelGeometry_cfi import *
from Geometry.HcalEventSetup.HcalGeometry_cfi import *
from Geometry.HcalEventSetup.CaloTowerGeometry_cfi import *
from Geometry.HcalEventSetup.CaloTowerTopology_cfi import *
from Geometry.HcalCommonData.hcalDDDRecConstants_cfi import *
from ElectroWeakAnalysis.Skimming.dimuonsMCMatch_cfi import *
#dimuonsMCMatch.src=cms.InputTag("userDataDimuons")
from ElectroWeakAnalysis.Skimming.dimuonsOneTrackMCMatch_cfi import *
#dimuonsOneTrackMCMatch.src=cms.InputTag("userDataDimuonsOneTrack")
#allDimuonsMCMatch = cms.EDFilter("GenParticleMatchMerger",
# src = cms.VInputTag(cms.InputTag("goodMuonMCMatch"), cms.InputTag("goodTrackMCMatch"), cms.InputTag("dimuonsMCMatch")),
# filter = cms.bool(False)
#)
allDimuonsMCMatch = cms.EDFilter("GenParticleMatchMerger",
src=cms.VInputTag(
cms.InputTag("goodMuonMCMatch"),
cms.InputTag("dimuonsMCMatch")),
filter=cms.bool(False))
allDimuonsOneTrackMCMatch = cms.EDFilter(
"GenParticleMatchMerger",
src=cms.VInputTag(cms.InputTag("goodMuonMCMatch"),
cms.InputTag("goodTrackMCMatch"),
cms.InputTag("dimuonsOneTrackMCMatch")),
filter=cms.bool(False))
# Different MCtruth sequences for different ZMuMu paths
mcTruthForDimuons = cms.Sequence(goodMuonMCMatch + dimuonsMCMatch +
allDimuonsMCMatch)
mcTruthForDimuonsOneTrack = cms.Sequence(goodMuonMCMatch + goodTrackMCMatch +
dimuonsOneTrackMCMatch +
allDimuonsOneTrackMCMatch)
'JEC/Fall17_17Nov2017B_V32_DATA_L1FastJet_AK4PFchs.txt',
'JEC/Fall17_17Nov2017B_V32_DATA_L2Relative_AK4PFchs.txt',
'JEC/Fall17_17Nov2017B_V32_DATA_L3Absolute_AK4PFchs.txt',
'JEC/Fall17_17Nov2017B_V32_DATA_L2L3Residual_AK4PFchs.txt'
]
jecLevelsAK4puppi = [
'JEC/Fall17_17Nov2017B_V32_DATA_L1FastJet_AK4PFPuppi.txt',
'JEC/Fall17_17Nov2017B_V32_DATA_L2Relative_AK4PFPuppi.txt',
'JEC/Fall17_17Nov2017B_V32_DATA_L3Absolute_AK4PFPuppi.txt',
'JEC/Fall17_17Nov2017B_V32_DATA_L2L3Residual_AK4PFPuppi.txt'
]
from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer
process.prefiringweight = l1ECALPrefiringWeightProducer.clone(
DataEra=cms.string("2016BtoH"), #("2017BtoF"), #Use 2016BtoH for 2016
UseJetEMPt=cms.bool(False),
PrefiringRateSystematicUncty=cms.double(0.2),
SkipWarnings=False)
process.JetUserData = cms.EDProducer(
'JetUserData',
jetLabel=cms.InputTag(jLabel),
rho=cms.InputTag("fixedGridRhoFastjetAll"),
coneSize=cms.double(0.4),
getJERFromTxt=cms.bool(False),
jetCorrLabel=cms.string(jetAlgo),
jerLabel=cms.string(jetAlgo),
resolutionsFile=cms.string(jer_era + '_PtResolution_' + jetAlgo + '.txt'),
scaleFactorsFile=cms.string(jer_era + '_SF_' + jetAlgo + '.txt'),
### TTRIGGER ###
triggerResults=cms.InputTag(triggerResultsLabel, "", hltProcess),
"hybridBarrelBasicClusters"),
conversionIOTrackProducer=cms.string('ckfInOutTracksFromConversions'),
outInTrackCollection=cms.string(''),
conversionOITrackProducer=cms.string('ckfOutInTracksFromConversions'),
inOutTrackCollection=cms.string(''),
inOutTrackSCAssociation=cms.string('inOutTrackSCAssociationCollection'),
outInTrackSCAssociation=cms.string('outInTrackSCAssociationCollection'),
convertedPhotonCollection=cms.string('uncleanedConversions'),
generalTracksSrc=cms.InputTag("generalTracks"),
hcalTowers=cms.InputTag("towerMaker"),
cleanedConvertedPhotonCollection=cms.string(''),
AlgorithmName=cms.string('ecalSeeded'),
minSCEt=cms.double(20.0),
hOverEConeSize=cms.double(0.15),
maxHOverE=cms.double(0.15),
recoverOneTrackCase=cms.bool(True),
dRForConversionRecovery=cms.double(0.3),
deltaCotCut=cms.double(0.05),
minApproachDisCut=cms.double(0.),
maxNumOfCandidates=cms.int32(3),
risolveConversionAmbiguity=cms.bool(True),
maxDelta=cms.double(0.01), #delta of parameters
maxReducedChiSq=cms.double(
225.), #maximum chi^2 per degree of freedom before fit is terminated
minChiSqImprovement=cms.double(
50.
), #threshold for "significant improvement" in the fit termination logic
maxNbrOfIterations=cms.int32(
40), #maximum number of convergence iterations
MVA_weights_location=cms.string(
'RecoEgamma/EgammaTools/data/TMVAnalysis_Likelihood.weights.txt')
import FWCore.ParameterSet.Config as cms
generator = cms.EDFilter(
"Pythia8PtGun",
PGunParameters=cms.PSet(
MaxPt=cms.double(35.01),
MinPt=cms.double(34.99),
ParticleID=cms.vint32(11),
AddAntiParticle=cms.bool(True),
MaxEta=cms.double(2.5),
MaxPhi=cms.double(3.14159265359),
MinEta=cms.double(-2.5),
MinPhi=cms.double(-3.14159265359) ## in radians
),
Verbosity=cms.untracked.int32(0), ## set to 1 (or greater) for printouts
psethack=cms.string('single electron pt 35'),
firstRun=cms.untracked.uint32(1),
PythiaParameters=cms.PSet(parameterSets=cms.vstring()))
from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
hcalRecoAnalyzer = DQMEDAnalyzer(
'HcalRecHitsValidation',
TopFolderName=cms.string('HcalRecHitsV/HcalRecHitTask'),
outputFile=cms.untracked.string('HcalRecHitValidationRelVal.root'),
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"),
ecalselector=cms.untracked.string('yes'),
hcalselector=cms.untracked.string('all'),
mc=cms.untracked.string('yes'),
SimHitCollectionLabel=cms.untracked.InputTag("g4SimHits", "HcalHits"),
TestNumber=cms.bool(False))
hcalNoiseRates = DQMEDAnalyzer(
'NoiseRates',
outputFile=cms.untracked.string('NoiseRatesRelVal.root'),
rbxCollName=cms.untracked.InputTag('hcalnoise'),
minRBXEnergy=cms.untracked.double(20.0),
minHitEnergy=cms.untracked.double(1.5),
noiselabel=cms.InputTag('hcalnoise'))
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(hcalRecoAnalyzer,
SimHitCollectionLabel=cms.untracked.InputTag(
"fastSimProducer", "HcalHits"))
from Configuration.Eras.Modifier_run2_HCAL_2017_cff import run2_HCAL_2017
# /dev/CMSSW_11_2_0/Fake2/V7 (CMSSW_11_2_0_pre9)
import FWCore.ParameterSet.Config as cms
process = cms.Process("HLTFake2")
process.HLTConfigVersion = cms.PSet(
tableName=cms.string('/dev/CMSSW_11_2_0/Fake2/V7'))
process.streams = cms.PSet(A=cms.vstring('InitialPD'))
process.datasets = cms.PSet(InitialPD=cms.vstring(
'HLT_Physics_v1', 'HLT_Random_v1', 'HLT_ZeroBias_v1'))
process.GlobalParametersRcdSource = cms.ESSource(
"EmptyESSource",
iovIsRunNotTime=cms.bool(True),
recordName=cms.string("L1TGlobalParametersRcd"),
firstValid=cms.vuint32(1))
process.GlobalTag = cms.ESSource(
"PoolDBESSource",
globaltag=cms.string("80X_dataRun2_HLT_v12"),
RefreshEachRun=cms.untracked.bool(False),
snapshotTime=cms.string(""),
toGet=cms.VPSet(),
DBParameters=cms.PSet(
authenticationPath=cms.untracked.string("."),
connectionRetrialTimeOut=cms.untracked.int32(60),
idleConnectionCleanupPeriod=cms.untracked.int32(10),
messageLevel=cms.untracked.int32(0),
enablePoolAutomaticCleanUp=cms.untracked.bool(False),
enableConnectionSharing=cms.untracked.bool(True),
fragment.datasets = cms.PSet(InitialPD=cms.vstring(
'HLT_Physics_v1', 'HLT_Random_v1', 'HLT_ZeroBias_v1'))
fragment.CastorDbProducer = cms.ESProducer("CastorDbProducer",
appendToDataLabel=cms.string(""))
fragment.hcalDDDRecConstants = cms.ESProducer("HcalDDDRecConstantsESModule",
appendToDataLabel=cms.string(""))
fragment.hcalDDDSimConstants = cms.ESProducer("HcalDDDSimConstantsESModule",
appendToDataLabel=cms.string(""))
fragment.hltGetConditions = cms.EDAnalyzer("EventSetupRecordDataGetter",
toGet=cms.VPSet(),
verbose=cms.untracked.bool(False))
fragment.hltGetRaw = cms.EDAnalyzer(
"HLTGetRaw", RawDataCollection=cms.InputTag("rawDataCollector"))
fragment.hltBoolFalse = cms.EDFilter("HLTBool", result=cms.bool(False))
fragment.hltTriggerType = cms.EDFilter("HLTTriggerTypeFilter",
SelectedTriggerType=cms.int32(1))
fragment.hltGtDigis = cms.EDProducer(
"L1GlobalTriggerRawToDigi",
DaqGtFedId=cms.untracked.int32(813),
Verbosity=cms.untracked.int32(0),
UnpackBxInEvent=cms.int32(5),
ActiveBoardsMask=cms.uint32(0xffff),
DaqGtInputTag=cms.InputTag("rawDataCollector"))
fragment.hltGctDigis = cms.EDProducer(
"GctRawToDigi",
checkHeaders=cms.untracked.bool(False),
unpackSharedRegions=cms.bool(False),
numberOfGctSamplesToUnpack=cms.uint32(1),
verbose=cms.untracked.bool(False),
import FWCore.ParameterSet.Config as cms
generator = cms.EDFilter("Herwig6HadronizerFilter",
comEnergy = cms.double(8000.0),
crossSection = cms.untracked.double(0.523),
doMPInteraction = cms.bool(True),
emulatePythiaStatusCodes = cms.untracked.bool(True),
filterEfficiency = cms.untracked.double(1.0),
herwigHepMCVerbosity = cms.untracked.bool(False),
herwigVerbosity = cms.untracked.int32(0),
lhapdfSetPath = cms.untracked.string(''),
maxEventsToPrint = cms.untracked.int32(0),
printCards = cms.untracked.bool(False),
useJimmy = cms.bool(True),
HerwigParameters = cms.PSet(
herwigUEsettings = cms.vstring(
'JMUEO = 1 ! multiparton interaction model',
'PTJIM = 4.449 ! 2.8x(sqrt(s)/1.8TeV)^0.27 @ 10 TeV',
'JMRAD(73) = 1.8 ! inverse proton radius squared',
'PRSOF = 0.0 ! prob. of a soft underlying event',
'MAXER = 1000000 ! max error'
),
herwigMcatnlo = cms.vstring(
'PTMIN = 0.5 ! minimum pt in hadronic jet'
),
parameterSets = cms.vstring('herwigUEsettings',
'herwigMcatnlo')
)
)
import FWCore.ParameterSet.Config as cms
ggHiNtuplizer = cms.EDAnalyzer("ggHiNtuplizer",
doGenParticles = cms.bool(False),
doElectrons = cms.bool(True),
doPhotons = cms.bool(True),
doMuons = cms.bool(True),
isParticleGun = cms.bool(False),
pileupSrc = cms.InputTag("addPileupInfo"),
genParticleSrc = cms.InputTag("genParticles"),
vertexSrc = cms.InputTag("offlineSlimmedPrimaryVertices"),
rhoSrc = cms.InputTag("fixedGridRhoFastjetAll"),
electronSrc = cms.InputTag("slimmedElectrons"),
photonSrc = cms.InputTag("slimmedPhotons"),
muonSrc = cms.InputTag("slimmedMuons"),
beamSpotSrc = cms.InputTag('offlineBeamSpot'),
conversionsSrc = cms.InputTag('reducedEgamma:reducedConversions'),
)
process.source = cms.Source(
"PoolSource",
fileNames=cms.untracked.vstring(options.inputFiles),
# skipBadFiles = cms.untracked.bool(True),
inputCommands=cms.untracked.vstring("keep *",
"drop *_MEtoEDMConverter_*_*"))
# HLT Selection ------------------------------------------------------------
process.load("HLTrigger.HLTfilters.triggerResultsFilter_cfi")
process.triggerResultsFilter.triggerConditions = cms.vstring(
options.triggerPath)
process.triggerResultsFilter.hltResults = cms.InputTag("TriggerResults", "",
options.HLTprocess)
process.triggerResultsFilter.l1tResults = cms.InputTag("")
process.triggerResultsFilter.throw = cms.bool(False)
process.seqHLTSelection = cms.Sequence(process.triggerResultsFilter)
if options.triggerPath == "*":
process.seqHLTSelection = cms.Sequence()
#--------------------------------------
#from DPGAnalysis.SiStripTools.occupancyplotsselections_cff import *
#from DPGAnalysis.SiStripTools.occupancyplotsselections_simplified_cff import *
#from DPGAnalysis.SiStripTools.occupancyplotsselections_pixelphase1_cff import *
from DPGAnalysis.SiStripTools.occupancyplotsselections_pixelphase1_detailed_cff import *
process.ssclusmultprod = cms.EDProducer(
"SiStripClusterMultiplicityProducer",
clusterdigiCollection=cms.InputTag("siStripClusters"),
wantedSubDets=cms.VPSet())
)
from HeavyIonsAnalysis.Configuration.CommonFunctions_cff import *
overrideCentrality(process)
process.HeavyIonGlobalParameters = cms.PSet(
centralityVariable = cms.string("HFtowers"),
nonDefaultGlauberModel = cms.string("Hydjet_Drum"),
centralitySrc = cms.InputTag("hiCentrality")
)
#Trigger Selection
### Comment out for the timing being assuming running on secondary dataset with trigger bit selected already
import HLTrigger.HLTfilters.hltHighLevel_cfi
process.hltHIMB = HLTrigger.HLTfilters.hltHighLevel_cfi.hltHighLevel.clone()
process.hltHIMB.HLTPaths = ['HLT_HIMinBiasHfOrBSC_*'] # for allphysics
process.hltHIMB.andOr = cms.bool(True)
process.hltHIMB.throw = cms.bool(False)
process.hltHIUCC = HLTrigger.HLTfilters.hltHighLevel_cfi.hltHighLevel.clone()
process.hltHIUCC.HLTPaths = ['HLT_HIUCC*_*'] # for allphysics
process.hltHIUCC.andOr = cms.bool(True)
process.hltHIUCC.throw = cms.bool(False)
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring(
#'/store/user/davidlw/HIMinBiasUPC/PR2011_MBUCC_TRKANASKIM_official_v1/71a7d203fff2b3f389673e6fdd587ee0/hiGoodColl_1023_1_S52.root'
#'root://xrootd.unl.edu//store/user/appeltel/HIMinBiasUPC/pixelTrackReco_devel_v0/a236e4501225ae15b3601563d612abb5/pixeltrackreco_6_1_qSR.root'
#'/store/user/davidlw/HIMinBiasUPC/Skim_rereco_pixeltracks_v1/4b65ef5aa7a26abf1f962cd25f7df02d/hiMB_88_1_qbI.root'
'/store/user/davidlw/Hydjet1p8_TuneDrum_Quenched_MinBias_2760GeV/RECO_5320_v1/71a485a731d6b2661f997f58ff50f0c0/reco_DIGI_L1_DIGI2RAW_RAW2DIGI_RECO_9_1_lpo.root'
)
# secondaryFileNames = cms.untracked.vstring('')
# MaxE = cms.double(5.0873)
# MinE = cms.double(6.0729),
# MaxE = cms.double(6.0729)
# MinE = cms.double(6.5674),
# MaxE = cms.double(6.5674)
# MinE = cms.double(7.0626),
# MaxE = cms.double(7.0626)
MinE = cms.double(7.5585),
MaxE = cms.double(7.5585)
# MinE = cms.double(8.3032),
# MaxE = cms.double(8.3032)
# MinE = cms.double(9.0488),
# MaxE = cms.double(9.0488)
),
Verbosity = cms.untracked.int32(0),
AddAntiParticle = cms.bool(False),
firstRun = cms.untracked.uint32(1)
)
process.Timing = cms.Service("Timing")
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
moduleSeeds = cms.PSet(
generator = cms.untracked.uint32(456789),
g4SimHits = cms.untracked.uint32(9876),
VtxSmeared = cms.untracked.uint32(123456789)
),
sourceSeed = cms.untracked.uint32(135799753)
)
process.p1 = cms.Path(process.generator*process.VtxSmeared*process.g4SimHits)
import FWCore.ParameterSet.Config as cms
#Note: distances in mm instead of in cm usually used in CMS
generator = cms.EDFilter(
"Pythia8PtAndLxyGun",
maxEventsToPrint=cms.untracked.int32(1),
pythiaPylistVerbosity=cms.untracked.int32(1),
pythiaHepMCVerbosity=cms.untracked.bool(True),
PGunParameters=cms.PSet(
ParticleID=cms.vint32(-15, -15),
AddAntiParticle=cms.bool(
True
), # antiparticle has opposite momentum and production point symmetric wrt (0,0,0) compared to corresponding particle
MinPt=cms.double(15.00),
MaxPt=cms.double(300.00),
MinEta=cms.double(-2.5),
MaxEta=cms.double(2.5),
MinPhi=cms.double(-3.14159265359),
MaxPhi=cms.double(3.14159265359),
LxyMin=cms.double(0.0),
LxyMax=cms.double(550.0), # most tau generated within TOB (55cm)
LzMax=cms.double(300.0),
dxyMax=cms.double(30.0),
dzMax=cms.double(120.0),
ConeRadius=cms.double(1000.0),
ConeH=cms.double(3000.0),
DistanceToAPEX=cms.double(850.0),
LxyBackFraction=cms.double(
0.0
), # fraction of particles going back towards to center at transverse plan; numbers outside the [0,1] range are set to 0 or 1
LzOppositeFraction=cms.double(
SLHAFileForPythia8 = cms.string('Configuration/Generator/data/LQ_uednue_beta0.5.out'),
PythiaParameters = cms.PSet(
pythia8CommonSettingsBlock,
pythia8CUEP8M1SettingsBlock,
processParameters = cms.vstring(
'LeptoQuark:gg2LQLQbar = on',
'LeptoQuark:qqbar2LQLQbar = on',
'42:m0 = 550 ! LQ mass',
),
parameterSets = cms.vstring('pythia8CommonSettings',
'pythia8CUEP8M1Settings',
'processParameters',
)
)
)
enuejjFilter = cms.EDFilter("LQGenFilter",
src = cms.untracked.InputTag("generator"),
eejj = cms.bool(False),
enuejj = cms.bool(True),
nuenuejj = cms.bool(False),
mumujj = cms.bool(False),
munumujj = cms.bool(False),
numunumujj = cms.bool(False)
)
ProductionFilterSequence = cms.Sequence(generator*enuejjFilter)
'MDME(226,1)=0 !Higgs decay into W W',
'CKIN(45)=1. !low mass cut on Z1',
'CKIN(47)=1. !low mass cut on Z2'),
# This is a vector of ParameterSet names to be read, in this order
parameterSets=cms.vstring('pythiaUESettings', 'processParameters')))
# if you need some filter modules define and configure them here
genParticlesForFilter = cms.EDProducer(
"GenParticleProducer",
saveBarCodes=cms.untracked.bool(True),
src=cms.InputTag("generator"),
abortOnUnknownPDGCode=cms.untracked.bool(True))
genSelectorFourLep = cms.EDFilter(
"GenParticleSelector",
filter=cms.bool(True),
src=cms.InputTag('genParticlesForFilter'),
cut=cms.string(
'(abs(pdgId()) == 11 || abs(pdgId()) == 13 || abs(pdgId()) == 15) && (mother().pdgId() == 23 || abs(mother().pdgId()) == 24)'
),
)
selectedFourLepCandFilter = cms.EDFilter(
"CandViewCountFilter",
src=cms.InputTag('genSelectorFourLep'),
filter=cms.bool(True),
minNumber=cms.uint32(4))
configurationMetadata = cms.untracked.PSet(
version=cms.untracked.string('$Revision: 1.1 $'),
name=cms.untracked.string(
import FWCore.ParameterSet.Config as cms
from PhysicsTools.PatAlgos.mcMatchLayer0.jetMatch_cfi import patJetGenJetMatch, patJetPartonMatch
from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import patJetCorrFactors
from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import patJets
from HeavyIonsAnalysis.JetAnalysis.inclusiveJetAnalyzer_cff import *
from HeavyIonsAnalysis.JetAnalysis.bTaggers_cff import *
from RecoJets.JetProducers.JetIDParams_cfi import *
from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness
akPu6Calomatch = patJetGenJetMatch.clone(
src=cms.InputTag("akPu6CaloJets"),
matched=cms.InputTag("ak6HiSignalGenJets"),
resolveByMatchQuality=cms.bool(False),
maxDeltaR=0.6)
akPu6CalomatchGroomed = patJetGenJetMatch.clone(
src=cms.InputTag("ak6HiSignalGenJets"),
matched=cms.InputTag("ak6HiSignalGenJets"),
resolveByMatchQuality=cms.bool(False),
maxDeltaR=0.6)
akPu6Caloparton = patJetPartonMatch.clone(
src=cms.InputTag("akPu6CaloJets"),
matched=cms.InputTag("hiSignalGenParticles"))
akPu6Calocorr = patJetCorrFactors.clone(useNPV=cms.bool(False),
useRho=cms.bool(False),
levels=cms.vstring('L2Relative'),
MinEta=cms.double(0.5655),
MaxEta=cms.double(0.5655),
MinPhi=cms.double(-0.1309),
MaxPhi=cms.double(-0.1309),
BeamPosition=cms.double(beamPosition))
from IOMC.EventVertexGenerators.VtxSmearedParameters_cfi import *
process.VtxSmeared = cms.EDProducer("BeamProfileVtxGenerator",
process.common_beam_direction_parameters,
VtxSmearedCommon,
BeamMeanX=cms.double(0.0),
BeamMeanY=cms.double(0.0),
BeamSigmaX=cms.double(0.0001),
BeamSigmaY=cms.double(0.0001),
Psi=cms.double(999.9),
GaussianProfile=cms.bool(False),
BinX=cms.int32(50),
BinY=cms.int32(50),
File=cms.string('beam.profile'),
UseFile=cms.bool(False),
TimeOffset=cms.double(0.))
process.source = cms.Source("EmptySource")
process.generator = cms.EDProducer(
"FlatRandomEGunProducer",
PGunParameters=cms.PSet(process.common_beam_direction_parameters,
MinE=cms.double(9.99),
MaxE=cms.double(10.01),
PartID=cms.vint32(211)),
Verbosity=cms.untracked.int32(0),
