def custom_3dclustering_clusteringRadiusNoLayerDependenceVariableEta(process,
distance_coefficientA=0.03,
distance_coefficientB=0.02):
parameters_c3d = process.hgcalBackEndLayer2Producer.ProcessorParameters.C3d_parameters
parameters_c3d.dR_multicluster_byLayer_coefficientA = cms.vdouble( [distance_coefficientA]*(MAX_LAYERS+1) )
parameters_c3d.dR_multicluster_byLayer_coefficientB = cms.vdouble( [distance_coefficientB]*(MAX_LAYERS+1) )
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 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 alcaHarvesting(self, globalTag, datasetName, **args):
"""
_alcaHarvesting_
Heavy-ion collisions data taking AlCa Harvesting
"""
options = defaultOptions
options.scenario = "HeavyIons"
options.step = "ALCAHARVEST:BeamSpotByRun+BeamSpotByLumi"
options.isMC = False
options.isData = True
options.beamspot = None
options.eventcontent = None
options.name = "ALCAHARVEST"
options.conditions = globalTag
options.arguments = ""
options.evt_type = ""
options.filein = []
process = cms.Process("ALCAHARVEST")
process.source = cms.Source("PoolSource")
configBuilder = ConfigBuilder(options, process = process)
configBuilder.prepare()
#
# customise process for particular job
#
process.source.processingMode = cms.untracked.string('RunsAndLumis')
process.source.fileNames = cms.untracked(cms.vstring())
process.maxEvents.input = -1
process.dqmSaver.workflow = datasetName
return process
def psetMinPtCut():
return cms.PSet(
cutName = cms.string("MinPtCut"),
minPt = cms.double(5.0),
needsAdditionalProducts = cms.bool(False),
isIgnored = cms.bool(False)
)
def makeAnalysisStep(self, stepName, **inputs):
step = super(GGHZZKFactors, self).makeAnalysisStep(stepName, **inputs)
if stepName == 'initialStateEmbedding':
sfFile = path.join(UWVV_BASE_PATH, 'data', 'kFactors',
'Kfactor_Collected_ggHZZ_2l2l_NNLO_NNPDF_NarrowWidth_13TeV.root')
ggKEmbedding4e = cms.EDProducer(
"GGHZZKFactorEmbedderEEEE",
src = step.getObjTag('eeee'),
fileName = cms.string(sfFile),
)
step.addModule('ggKEmbedding4e', ggKEmbedding4e, 'eeee')
ggKEmbedding2e2m = cms.EDProducer(
"GGHZZKFactorEmbedderEEMuMu",
src = step.getObjTag('eemm'),
fileName = cms.string(sfFile),
)
step.addModule('ggKEmbedding2e2m', ggKEmbedding2e2m, 'eemm')
ggKEmbedding4m = cms.EDProducer(
"GGHZZKFactorEmbedderMuMuMuMu",
src = step.getObjTag('mmmm'),
fileName = cms.string(sfFile),
)
step.addModule('ggKEmbedding4m', ggKEmbedding4m, 'mmmm')
return step
def CreatePlotEntry(analyzer, discriminatorLabel=None, step=True):
"""CreatePlotEntry(analyzer, discriminatorLabel)\n
Creates a PSet with the informations used by TauDQMHistEffProducer\n
where to find the numerator and denominator\n
where to put the new plot and how to name it\n
which variables control"""
producer = analyzer.TauProducer.pythonValue()[1:-1]
ext = analyzer.ExtensionName.pythonValue()[1:-1]
if discriminatorLabel == None:
num = 'RecoTauV/%s%s_Matched/%sMatched_vs_#PAR#TauVisible'%(producer,ext,producer)
#out = 'RecoTauV/%s%s_Matched/PFJetMatchingEff#PAR#'%(producer,ext)
if producer.find('caloReco') != -1:
out = 'RecoTauV/%s%s_Matched/CaloJetMatchingEff#PAR#'%(producer,ext)
else:
out = 'RecoTauV/%s%s_Matched/PFJetMatchingEff#PAR#'%(producer,ext)
else:
num = 'RecoTauV/%s%s_%s/%s_vs_#PAR#TauVisible'%(producer,ext,discriminatorLabel,discriminatorLabel)
if discriminatorLabel.find('DiscriminationBy') != -1:
hname = discriminatorLabel[(discriminatorLabel.find('DiscriminationBy')+len('DiscriminationBy')):]
else:
hname = discriminatorLabel[(discriminatorLabel.find('Discrimination')+len('Discrimination')):]
out = 'RecoTauV/%s%s_%s/%sEff#PAR#'%(producer,ext,discriminatorLabel,hname)
den = 'RecoTauV/%s%s_ReferenceCollection/nRef_Taus_vs_#PAR#TauVisible'%(producer,ext)
ret = cms.PSet(
numerator = cms.string(num),
denominator = cms.string(den),
efficiency = cms.string(out),
parameter = cms.vstring('pt', 'eta', 'phi', 'pileup'),
stepByStep = cms.bool(step)
)
return ret
def setCondition(process,
connect = "frontier://FrontierProd/CMS_CONDITIONS",
record = None,
tag = None,
label = None):
"""
Overrides a condition in startgeometry from globaltag.
"""
if record is None or tag is None:
raise ValueError("A 'record' and a 'tag' have to be provided to 'setCondition'.")
if not hasattr(process, "GlobalTag"):
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
args = {"connect": cms.string(connect),
"record": cms.string(record),
"tag": cms.string(tag)}
if label is not None:
args["label"] = cms.untracked.string(label)
process.GlobalTag.toGet \
= cms.VPSet(filter(lambda x: x.record.value() != record,
process.GlobalTag.toGet.value()))
process.GlobalTag.toGet.append(cms.PSet(**args))
def loadLocalJECDBfile(process,
dbfile = '',
tag = 'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI',
label = 'AK4PFPuppi'):
#===================================================
# local BD reader
# load and replace the data base by the local one
#===================================================
#print ':: dbfile == ', dbfile
process.load("CondCore.DBCommon.CondDBCommon_cfi")
process.load("CondCore.DBCommon.CondDBSetup_cfi")
setattr(process, 'jec' + label,
cms.ESSource("PoolDBESSource",
DBParameters = cms.PSet(
messageLevel = cms.untracked.int32(0)
),
timetype = cms.string('runnumber'),
toGet = cms.VPSet(cms.PSet(
record = cms.string('JetCorrectionsRecord'),
tag = cms.string(tag),
label = cms.untracked.string(label)
)),
connect = cms.string('sqlite_file:%s' % dbfile)
))
setattr(process, 'es_prefer_jec' + label,
cms.ESPrefer('PoolDBESSource','jec'+ label))
def testNoSchedule(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.a = cms.EDProducer("AProd")
process.b = cms.EDProducer("BProd")
process.c = cms.EDProducer("CProd")
process.d = cms.EDProducer("DProd")
process.m = cms.EDProducer("MProd")
process.n = cms.EDProducer("NProd")
process.r = cms.EDProducer("RProd")
process.s = cms.EDProducer("SProd")
process.t1 = cms.Task(process.m)
t2 = cms.Task(process.n)
process.f1 = cms.EDFilter("Filter")
process.f2 = cms.EDFilter("Filter2")
process.f3 = cms.EDFilter("Filter3")
process.f4 = cms.EDFilter("FIlter4")
process.out1 = cms.OutputModule("Output1")
process.out2 = cms.OutputModule("Output2")
process.analyzer1 = cms.EDAnalyzer("analyzerType1")
process.analyzer2 = cms.EDAnalyzer("analyzerType2")
process.p1 = cms.Path(process.a+process.b+process.f1+process.analyzer1+cms.ignore(process.d)+cms.ignore(process.f2))
process.p4 = cms.Path(process.a+process.f2+process.b+~process.f1+cms.ignore(process.f4))
process.p2 = cms.Path(process.a+process.b)
process.p3 = cms.Path(process.f1, process.t1, t2)
process.t3 = cms.Task(process.r)
process.t4 = cms.Task(process.s)
process.s1 = cms.Sequence(~process.a, process.t3)
process.p5 = cms.Path(process.b + process.s1, process.t4)
process.end1 = cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2+process.a+process.b+cms.ignore(process.f1))
process.end2 = cms.EndPath()
convertToUnscheduled(process)
self.assert_(hasattr(process,'p2'))
self.assert_(hasattr(process,'a'))
self.assert_(hasattr(process,'b'))
self.assert_(hasattr(process,'c'))
self.assert_(hasattr(process,'d'))
self.assert_(hasattr(process,'f1'))
self.assert_(hasattr(process,'f2'))
self.assert_(hasattr(process,'f3'))
self.assert_(hasattr(process,'f4'))
self.assert_(hasattr(process,'out1'))
self.assert_(hasattr(process,'out2'))
self.assert_(hasattr(process,'analyzer1'))
self.assert_(hasattr(process,'analyzer2'))
self.assertEqual(process.p1.dumpPython(None),'cms.Path(process.f1+process.analyzer1, cms.Task(process.a, process.b, process.d, process.f2))\n')
self.assertEqual(process.p2.dumpPython(None),'cms.Path(cms.Task(process.a, process.b))\n')
self.assertEqual(process.p3.dumpPython(None),'cms.Path(process.f1, cms.Task(process.m, process.n))\n')
self.assertEqual(process.p4.dumpPython(None),'cms.Path(process.f2+~process.f1, cms.Task(process.a, process.b, process.f4))\n')
self.assertEqual(process.p5.dumpPython(None),'cms.Path(cms.Task(process.a, process.b), cms.Task(process.r, process.s))\n')
self.assertEqual(process.end1.dumpPython(None),'cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2, cms.Task(process.a, process.b, process.f1))\n')
self.assertEqual(process.end2.dumpPython(None),'cms.EndPath()\n')
def customise_csc_cond_ungangedME11A_mc(process):
""" Pick up upgrade condions data directly from DB tags using ESPrefer's.
Might be useful when dealing with a global tag that doesn't include
'unganged' CSC conditions.
"""
myconds = [
('CSCDBGainsRcd', 'CSCDBGains_ungangedME11A_mc'),
('CSCDBNoiseMatrixRcd', 'CSCDBNoiseMatrix_ungangedME11A_mc'),
('CSCDBCrosstalkRcd', 'CSCDBCrosstalk_ungangedME11A_mc'),
('CSCDBPedestalsRcd', 'CSCDBPedestals_ungangedME11A_mc'),
('CSCDBGasGainCorrectionRcd', 'CSCDBGasGainCorrection_ungangedME11A_mc'),
('CSCDBChipSpeedCorrectionRcd', 'CSCDBChipSpeedCorrection_ungangedME11A_mc')
]
from CalibMuon.Configuration.getCSCConditions_frontier_cff import cscConditions
for (classname, tag) in myconds:
print classname, tag
sourcename = 'unganged_' + classname
process.__setattr__(sourcename, cscConditions.clone())
process.__getattribute__(sourcename).toGet = cms.VPSet( cms.PSet( record = cms.string(classname), tag = cms.string(tag)) )
process.__getattribute__(sourcename).connect = cms.string('frontier://FrontierProd/CMS_COND_CSC_000')
process.__setattr__('esp_' + classname, cms.ESPrefer("PoolDBESSource", sourcename) )
del cscConditions
return process
def customise_Validation(process,pileup):
process.validation_step.remove(process.PixelTrackingRecHitsValid)
process.validation_step.remove(process.stripRecHitsValid)
process.validation_step.remove(process.trackerHitsValid)
process.validation_step.remove(process.StripTrackingRecHitsValid)
# We don't run the HLT
process.validation_step.remove(process.HLTSusyExoVal)
process.validation_step.remove(process.hltHiggsValidator)
process.validation_step.remove(process.relvalMuonBits)
if pileup>30:
process.trackValidator.label=cms.VInputTag(cms.InputTag("cutsRecoTracksHp"))
process.tracksValidationSelectors = cms.Sequence(process.cutsRecoTracksHp)
process.globalValidation.remove(process.recoMuonValidation)
process.validation.remove(process.recoMuonValidation)
process.validation_preprod.remove(process.recoMuonValidation)
process.validation_step.remove(process.recoMuonValidation)
process.validation.remove(process.globalrechitsanalyze)
process.validation_prod.remove(process.globalrechitsanalyze)
process.validation_step.remove(process.globalrechitsanalyze)
process.validation.remove(process.stripRecHitsValid)
process.validation_step.remove(process.stripRecHitsValid)
process.validation_step.remove(process.StripTrackingRecHitsValid)
process.globalValidation.remove(process.vertexValidation)
process.validation.remove(process.vertexValidation)
process.validation_step.remove(process.vertexValidation)
process.mix.input.nbPileupEvents.averageNumber = cms.double(0.0)
process.mix.minBunch = cms.int32(0)
process.mix.maxBunch = cms.int32(0)
if hasattr(process,'simHitTPAssocProducer'):
process.simHitTPAssocProducer.simHitSrc=cms.VInputTag(cms.InputTag("g4SimHits","TrackerHitsPixelBarrelLowTof"),
cms.InputTag("g4SimHits","TrackerHitsPixelEndcapLowTof"))
return process
def customise(process):
process.load('GeneratorInterface.RivetInterface.rivetAnalyzer_cfi')
process.rivetAnalyzer.AnalysisNames = cms.vstring('CMS_EWK_10_012')
process.rivetAnalyzer.OutputFile= cms.string('WToENuPythia.aida')
process.generation_step+=process.rivetAnalyzer
process.schedule.remove(process.RAWSIMoutput_step)
return(process)
def custom_3dclustering_distance(process,
distance=0.01
):
parameters_c3d = process.hgcalTriggerPrimitiveDigiProducer.BEConfiguration.algorithms[0].C3d_parameters
parameters_c3d.dR_multicluster = cms.double(distance)
parameters_c3d.type_multicluster = cms.string('dRC3d')
return process
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 addEventHypothesis(process,label,thisMuTag,thisEleTag,thisSoftMuTag='wwMuons4Veto',preSequence=cms.Sequence()):
hypos = ['ellell']
#hypos = ['mumu','muel','elmu','elel']
process.peakingFilter = cms.EDFilter("GenFilterDiBosons")
tempSkimEventFilter = cms.EDFilter("SkimEventSelector",
src = cms.InputTag(""),
filter = cms.bool(True),
cut = cms.string("nLep >=2 "),
)
for hypo in hypos:
#create the four hypothesis:
setattr(process,'ww'+hypo+label,process.skimEventProducer.clone(hypoType='WW'+hypo.upper(),muTag=thisMuTag,elTag=thisEleTag,softMuTag=thisSoftMuTag))
#create SkimEventSelectors (asking for nLep >=2)
setattr(process,'skim'+hypo+label,tempSkimEventFilter.clone(src='ww'+hypo+label))
# create sequence
# p = cms.Path(preSequence)
# if peakingType == 'peaking': p = cms.Path( process.peakingFilter)
# if peakingType == 'non-peaking': p = cms.Path(~process.peakingFilter)
p = cms.Path(
getattr(process,thisMuTag) +
getattr(process,thisEleTag) +
getattr(process,thisSoftMuTag) +
getattr(process,'ww'+hypo+label) +
getattr(process,'skim'+hypo+label)
)
setattr(process,'sel'+hypo+label,p)
# add to scheduler
if getattr(process,'schedule') != None: process.schedule.append( getattr(process,'sel'+hypo+label) )
# add to pooloutput module
if hasattr(process,'out'): process.out.outputCommands.append( 'keep *_{0}_*_*'.format( 'ww'+hypo+label ) )
if hasattr(process,'out'): process.out.SelectEvents.SelectEvents.append( 'sel'+hypo+label )
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 SpawnPSet(lArgument, subPset):
"""SpawnPSet(lArgument, subPset) --> cms.PSet\n
lArgument is a list containing a list of three strings/values:\n
1-name to give to the spawned pset\n
2-variable(s) to be changed\n
3-value(s) of the variable(s): SAME LENGTH OF 2-!\n
Supported types: int string float(converted to double)"""
ret = cms.PSet()
for spawn in lArgument:
if len(spawn) != 3:
print "ERROR! SpawnPSet uses argument of three data\n"
print self.__doc__
return None
if len(spawn[1]) != len(spawn[2]):
print "ERROR! Lists of arguments to replace must have the same length"
print self.__doc__
return None
spawnArg = copy.deepcopy(subPset)
for par, val in zip(spawn[1],spawn[2]):
if isinstance(val, str) :
setattr(spawnArg,par,cms.string(val))
elif isinstance(val, int) :
setattr(spawnArg,par,cms.int32(val))
elif isinstance(val, float) :
setattr(spawnArg,par,cms.double(val))
setattr(ret,spawn[0],spawnArg)
return ret
def addPhotonReReco(process, isAOD=False):
"""Include the photon re-reco sequence in the patDefaultSequence
See https://hypernews.cern.ch/HyperNews/CMS/get/egamma/960.html
and
https://hypernews.cern.ch/HyperNews/CMS/get/egamma/958/1/1/1/1/1/1/1/1/1/1/1.html
"""
if isAOD:
process.photons.barrelEcalHits = cms.InputTag("reducedEcalRecHitsEB")
process.photons.endcapEcalHits = cms.InputTag("reducedEcalRecHitsEE")
from RecoEgamma.PhotonIdentification.isolationCalculator_cfi \
import isolationSumsCalculator as isc
isc.barrelEcalRecHitProducer = cms.string('reducedEcalRecHitsEB')
isc.endcapEcalRecHitProducer = cms.string('reducedEcalRecHitsEE')
isc.barrelEcalRecHitCollection = cms.InputTag('reducedEcalRecHitsEB')
isc.endcapEcalRecHitCollection = cms.InputTag('reducedEcalRecHitsEE')
process.photons.isolationSumsCalculatorSet = isc
process.photonReReco = cms.Sequence( process.photonSequence *
process.photonIDSequence )
else:
process.photonReReco = cms.Sequence( process.ckfTracksFromConversions *
process.conversionSequence *
process.photonSequence *
process.photonIDSequence )
# Edit the pat sequence to do the rereco
process.patDefaultSequence = cms.Sequence(process.photonReReco*
process.patDefaultSequence)
def get(todo):
defs = {}
# HFRecHits
defs["HFRecHitView"] = cms.PSet(
miniView = cms.string("HFRecHitView"),
branchPrefix = cms.untracked.string("HFRecHit"),
)
# HBHERecHits
defs["HBHERecHitView"] = cms.PSet(
miniView = cms.string("HBHERecHitView"),
branchPrefix = cms.untracked.string("HBHERecHit"),
)
# EcalRecHits
defs["EcalRecHitView"] = cms.PSet(
miniView = cms.string("EcalRecHitView"),
branchPrefix = cms.untracked.string("EcalRecHit"),
)
# main function
ret = {}
for t in todo:
if t not in defs:
raise Exception("miniView def not known "+t)
ret[t] = defs[t]
return ret
def addEventHypothesis(process,label,thisMuTag,thisEleTag,thisSoftMuTag='wwMuons4Veto',preSequence=cms.Sequence()):
process.peakingFilter = cms.EDFilter("GenFilterDiBosons")
tempSkimEventFilter = cms.EDFilter("SkimEventSelector",
src = cms.InputTag(""),
filter = cms.bool(True),
cut = cms.string("1"),
#cut = cms.string("nLep >=2 "),
)
#create the only hypothesis (>= 1 lepton):
setattr(process,'ww'+label,process.skimEventProducer.clone(muTag=thisMuTag,elTag=thisEleTag,softMuTag=thisSoftMuTag))
#create SkimEventSelectors (asking for nLep >=2)
setattr(process,'skim'+label,tempSkimEventFilter.clone(src='ww'+label))
# create sequence
p = cms.Path(
getattr(process,'ww'+label) +
getattr(process,'skim'+label)
)
setattr(process,'sel'+label,p)
# add to scheduler
if getattr(process,'schedule') != None: process.schedule.append( getattr(process,'sel'+label) )
# add to pooloutput module
if hasattr(process,'out'): process.out.outputCommands.append( 'keep *_{0}_*_*'.format( 'ww'+label ) )
if hasattr(process,'out'): process.out.SelectEvents.SelectEvents.append( 'sel'+label )
def addPoolDBESSource( process,
moduleName,
record,
tag,
connect='sqlite_file:',
label='',):
from CondCore.CondDB.CondDB_cfi import CondDB
calibDB = cms.ESSource("PoolDBESSource",
CondDB,
timetype = cms.string('runnumber'),
toGet = cms.VPSet(cms.PSet(
record = cms.string(record),
tag = cms.string(tag),
label = cms.untracked.string(label)
)),
)
calibDB.connect = cms.string( str(connect) )
#if authPath: calibDB.DBParameters.authenticationPath = authPath
if 'oracle:' in connect:
calibDB.DBParameters.authenticationPath = '/afs/cern.ch/cms/DB/conddb'
setattr(process,moduleName,calibDB)
setattr(process,"es_prefer_" + moduleName,cms.ESPrefer('PoolDBESSource',
moduleName)
)
def custom_cluster_calibration_global(process,
factor=1.084
):
parameters_c2d = process.hgcalBackEndLayer1Producer.ProcessorParameters.C2d_parameters
parameters_c2d.calibSF_cluster = cms.double(factor)
parameters_c2d.applyLayerCalibration = 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 electronTriggerMatchPT(process,triggerProcess):
process.triggeredPatElectronsL = cms.EDProducer("ElectronTriggerMatcher",
src = cms.InputTag("cleanPatElectrons"),
trigEvent = cms.InputTag("hltTriggerSummaryAOD"),
filters = cms.VInputTag(
cms.InputTag('hltEle17CaloIdLCaloIsoVLPixelMatchFilterDoubleEG125','',triggerProcess),
),
pdgId = cms.int32(0)
)
process.triggeredPatElectrons = cms.EDProducer("ElectronTriggerMatcher",
src = cms.InputTag("triggeredPatElectronsL"),
trigEvent = cms.InputTag("hltTriggerSummaryAOD"),
filters = cms.VInputTag(
cms.InputTag('hltOverlapFilterIsoEle15IsoPFTau20','',triggerProcess),
cms.InputTag('hltOverlapFilterIsoEle15TightIsoPFTau20','',triggerProcess),
cms.InputTag('hltOverlapFilterIsoEle18MediumIsoPFTau20','',triggerProcess),
cms.InputTag('hltOverlapFilterIsoEle18TightIsoPFTau20','',triggerProcess),
cms.InputTag('hltOverlapFilterIsoEle18IsoPFTau20','',triggerProcess),
cms.InputTag('hltOverlapFilterIsoEle20MediumIsoPFTau20','',triggerProcess),
cms.InputTag('hltOverlapFilterIsoEle20LooseIsoPFTau20','',triggerProcess),
cms.InputTag('hltOverlapFilterIsoEle20WP90LooseIsoPFTau20','',triggerProcess),
cms.InputTag('hltEle20CaloIdVTCaloIsoTTrkIdTTrkIsoTTrackIsoFilterL1IsoEG18OrEG20','',triggerProcess),
cms.InputTag('hltEle22WP90RhoTrackIsoFilter','',triggerProcess),
cms.InputTag('hltEle27WP80TrackIsoFilter','',triggerProcess),
cms.InputTag('hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoFilter','',triggerProcess),
cms.InputTag('hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoDoubleFilter','',triggerProcess),
cms.InputTag('hltEle17CaloIdVTCaloIsoVTTrkIdTTrkIsoVTEle8TrackIsoFilter','',triggerProcess),
cms.InputTag('hltEle20CaloIdVTCaloIsoVTTrkIdTTrkIsoVTSC4TrackIsoFilter','',triggerProcess)
),
pdgId = cms.int32(11)
)
process.analysisSequence=cms.Sequence(process.analysisSequence*process.triggeredPatElectronsL*process.triggeredPatElectrons)
def customise_pu_protons_ctpps(process):
process=customise(process)
process.mix.mixObjects.mixHepMC.makeCrossingFrame = cms.untracked.bool(True)
process.ppssim.UseHepMCProducer = cms.untracked.bool(False)
# PU gen particle
process.genParticlesPU = cms.EDProducer("GenParticleProducer",
saveBarCodes = cms.untracked.bool(True),
mix = cms.string("mix"),
abortOnUnknownPDGCode = cms.untracked.bool(False),
useCrossingFrame = cms.untracked.bool(True)
)
process.genProtonsPU = cms.EDFilter("GenParticleSelector",
filter = cms.bool(False),
src = cms.InputTag("genParticlesPU"),
cut = cms.string('')
)
process.genProtonsPU.cut = 'status = 1 & pdgId == 2212 & abs(pz) >= %f' % ( 0.5*13000./2.0)
outputCommandsPU = [ 'keep *_genParticlesPU_*_*', 'keep *_genProtonsPU_*_*']
process.ppssim.genSource = cms.InputTag("genProtonsPU") # for Pile-up events
#process.digitisation_step.replace(process.pdigi_valid, process.pdigi_valid * process.genParticlesPU * process.genProtonsPU)
process.digitisation_step.replace(process.ppssim, process.genParticlesPU * process.genProtonsPU * process.ppssim)
return (process)
def addSusyParticleVariables(pt):
if hasattr(pt,"variables"):
pt.variables.std_vector_susy_pt = cms.string("susyParticlePt/4")
pt.variables.std_vector_susy_eta = cms.string("susyParticleEta/4")
pt.variables.std_vector_susy_phi = cms.string("susyParticlePhi/4")
pt.variables.std_vector_susy_id = cms.string("susyParticleID/4")
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 addTauEmbeddingMuonTausUsingVisible(process, prefix = "tauEmbeddingGenTauVisibleMatch"):
seq = cms.Sequence()
m = cms.EDFilter("GenParticleSelector",
src = cms.InputTag("genParticles", "", "EMBEDDING"),
cut = cms.string(generatorTauSelection % generatorTauPt)
)
genTausName = prefix+"GenTaus"
setattr(process, genTausName, m)
seq *= m
m = cms.EDProducer("HPlusGenVisibleTauComputer",
src = cms.InputTag(genTausName)
)
visibleName = prefix+"GenTausVisible"
setattr(process, visibleName, m)
seq *= m
m = cms.EDProducer("HPlusPATTauLorentzVectorViewClosestDeltaRSelector",
# src = cms.InputTag("selectedPatTaus"+PF2PATVersion), # not trigger matched
# src = cms.InputTag("selectedPatTausHpsPFTau", "", "EMBEDDING"), # 2011
src = cms.InputTag("selectedPatTaus", "", "EMBEDDING"),
refSrc = cms.InputTag(visibleName),
maxDeltaR = cms.double(0.5),
)
setattr(process, prefix+"TauMatched", m)
seq *= m
return seq