def customizeJetSystematicsForData(process):
# By default remove the systematic entirely
# For JEC, re-do central value in case the global tag has been updated
process.jec.toGet[0].tag = cms.string(process.jec.toGet[0].tag.value().replace("MC","DATA"))
process.jec.connect = cms.string(process.jec.connect.value().replace("MC","DATA"))
from flashgg.Taggers.flashggTags_cff import UnpackedJetCollectionVInputTag
jetsystprodlist = [getattr(process,"flashggJetSystematics%i"%i) for i in range(len(UnpackedJetCollectionVInputTag))]
for systprod in jetsystprodlist:
# For updating bugged or unavailable JEC
# It should be a noop in cases where they are already correct
newvpset = cms.VPSet()
for pset in systprod.SystMethods:
if pset.Label.value().count("JEC"):
pset.NSigmas = cms.vint32() # Do not perform shifts, central value only
pset.SetupUncertainties = False
pset.JetCorrectorTag = cms.InputTag("ak4PFCHSL1FastL2L3ResidualCorrector")
newvpset += [pset]
systprod.SystMethods = newvpset
process.load("JetMETCorrections/Configuration/JetCorrectionServices_cff")
process.jetCorrectorChain = cms.Sequence(process.ak4PFCHSL1FastL2L3ResidualCorrectorChain)
#hopefully a temporary hack (2016 data)
# from os import environ
# process.jec.connect = cms.string('sqlite_file:%s/src/flashgg/Systematics/data/JEC/Summer16_23Sep2016AllV4_DATA.db' % environ['CMSSW_BASE'])
# process.jec.toGet[0].tag = cms.string('JetCorrectorParametersCollection_Summer16_23Sep2016AllV4_DATA_AK4PFchs')
# Update this hack for 2017 data
from os import environ
process.jec.connect = cms.string('sqlite_file:%s/src/flashgg/Systematics/data/JEC/Fall17_17Nov2017BCDEF_V6_DATA.db' % environ['CMSSW_BASE'])
process.jec.toGet[0].tag = cms.string('JetCorrectorParametersCollection_Fall17_17Nov2017BCDEF_V6_DATA_AK4PFchs')
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 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 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 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 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 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 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 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 makeCategoryParams(llWPs=[], diLeptonTriggerMatch=False, addPassAll=False):
categs = dict() ## take dilepton working points from input
for l1 in ("El", "Mu"):
for l2 in ("El", "Mu"):
flav = "".join((l1,l2))
base = cms.PSet(
NElectrons = cms.uint32(sum( 1 for l in (l1,l2) if l == "El" ))
, NMuons = cms.uint32(sum( 1 for l in (l1,l2) if l == "Mu" ))
, Category = cms.string("is{0}".format(flav))
, HLT = cms.vstring(dileptonTriggers[flav]) if diLeptonTriggerMatch else cms.vstring()
, Cuts = cms.VPSet(
cms.PSet(Mll = cms.string("p4.M > 20"))
, cms.PSet(ZVeto = cms.string("( p4.M < 76 ) || ( p4.M > 116 )"))
)
, WPs=cms.vstring(llWPs)
)
categs["{0}OS".format(flav)] = base.clone(Charge=cms.int32( 0), Category=cms.string("is{0} && isOS".format(flav)))
categs["{0}Plus".format(flav)] = base.clone(Charge=cms.int32( 1))
categs["{0}Minus".format(flav)] = base.clone(Charge=cms.int32(-1))
if addPassAll:
categs["all"] = cms.PSet(
NElectrons = cms.uint32(0)
, NMuons = cms.uint32(0)
, Category = cms.string("")
, HLT = cms.vstring()
, Cuts = cms.VPSet()
, WPs = cms.vstring()
, Charge = cms.int32(0)
)
return cms.PSet(**categs)
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 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 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 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 createJERESource(process):
datadir = "%s/src/flashgg/Systematics/data/JER" % environ['CMSSW_BASE']
print "WARNING: we are reading JER from %s so GRID jobs might not work" % datadir
process.load('Configuration.StandardSequences.Services_cff')
process.load("JetMETCorrections.Modules.JetResolutionESProducer_cfi")
from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
process.jer = cms.ESSource("PoolDBESSource",
CondDBSetup,
toGet = cms.VPSet(
# Resolution
cms.PSet(
record = cms.string('JetResolutionRcd'),
tag = cms.string('JR_Spring16_25nsV6_MC_PtResolution_AK4PFchs'),
label = cms.untracked.string('AK4PFchs_pt')
),
# Scale factors
cms.PSet(
record = cms.string('JetResolutionScaleFactorRcd'),
tag = cms.string('JR_Spring16_25nsV6_MC_SF_AK4PFchs'),
label = cms.untracked.string('AK4PFchs')
),
),
# [2016-02-21 14:50:14,703] INFO: Connecting to Systematics/data/JER/Summer15_25nsV6_MC.db [sqlite:///Systematics/data/JER/Summer15_25nsV6_MC.db]
# JR_Summer15_25nsV6_MC_SF_AK4PFchs Run JME::JetResolutionObject any -1 2016-02-05 20:59:34.061327 New Tag
# JR_Summer15_25nsV6_MC_PtResolution_AK4PFchs Run JME::JetResolutionObject any -1 2016-02-05 20:59:34.064554 New Tag
connect = cms.string('sqlite_file:%s/Spring16_25nsV6_MC.db' % datadir)
)
process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')
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 addMuVars( s3 ):
vars = {}
flags = {}
muVars = dict(
normalizedChi2 = "? {0}.isGlobalMuon ? {0}.globalTrack.normalizedChi2 : -9999",
numberOfValidMuonHits = "? {0}.isGlobalMuon ? {0}.globalTrack.hitPattern.numberOfValidMuonHits : -9999",
numberOfMatches = "? {0}.isGlobalMuon ? {0}.numberOfMatches : -9999",
TMLastStationTight = "? {0}.isTrackerMuon ? {0}.muonID('TMLastStationTight') : -9999",
trkKink = "{0}.combinedQuality.trkKink",
trackerLayersWithMeasurement = "{0}.innerTrack.hitPattern.trackerLayersWithMeasurement",
numberOfValidPixelHits = "{0}.innerTrack.hitPattern.numberOfValidPixelHits",
trackRelErr = "abs({0}.track.ptError / {0}.pt)",
# trackRelErr2 = "abs({0}.track.ptError / {0}.track.pt)",
)
muFlags = dict(
isGlobalMuon = "{0}.isGlobalMuon()",
isTrakerMuon = "{0}.isTrackerMuon()",
isPFMuon = "{0}.isPFMuon",
)
for i in [0,1]:
for (name,raw) in muVars.iteritems():
formula = ('? abs({0}.pdgId) == 13 ? '+raw+' : -9999').format('candByPt('+str(i)+')')
vars[name+str(i+1)] = cms.string(formula)
for (name,raw) in muFlags.iteritems():
formula = ('? abs({0}.pdgId) == 13 ? '+raw+' : -9999').format('candByPt('+str(i)+')')
flags[name+str(i+1)] = cms.string(formula)
addVarFlags(s3, vars = vars, flags = flags)
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 ecal_complete_aging_3000(process):
process=ecal_complete_aging(process)
if not hasattr(process.GlobalTag,'toGet'):
process.GlobalTag.toGet=cms.VPSet()
process.GlobalTag.toGet.extend( cms.VPSet(
cms.PSet(record = cms.string("EcalPedestalsRcd"),
tag = cms.string("EcalPedestals_TL3000_IL5E34_mc"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL")
),
## laser D
cms.PSet(record = cms.string("EcalLaserAPDPNRatiosRcd"),
tag = cms.string("EcalLaserAPDPNRatios_TL3000_IL5E34_v2_mc"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL")
),
## L1 trigger
cms.PSet(record = cms.string("EcalTPGLinearizationConstRcd"),
tag = cms.string("EcalTPGLinearizationConst_TL3000_IL5E34_v2_mc"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL")
),
cms.PSet(record = cms.string('EcalLaserAlphasRcd'),
tag = cms.string('EcalLaserAlphas_EB_sic1_btcp1_EE_sic1_btcp1'),
connect = cms.untracked.string('frontier://FrontierPrep/CMS_COND_ECAL')
),
#VPT aging
cms.PSet(record = cms.string('EcalLinearCorrectionsRcd'),
tag = cms.string('EcalLinearCorrections_mc'),
connect = cms.untracked.string('frontier://FrontierPrep/CMS_COND_ECAL')
)
)
)
return process
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 reduce(self, sort):
# reduce can be MEAN or COUNT. in STAGE2, just pass through.
# in STAGE1, MEAN (anywhere) means make a PROFILE
# COUNT can mean per-event counting or a occupancy plot, which is acheived
# by ignoring the values passed to fill() (like dimensions=0, TODO).
if self._state == FIRST:
if sort != "COUNT":
raise Exception("First statement must be groupBy.")
self.spec[0].type = COUNT # this is actually a noop
# groupBy already saw the "Event" column and set up counting.
return self
if self._state == STAGE1:
if sort == "MEAN":
self.spec.append(cms.PSet(
type = PROFILE, stage = STAGE1,
columns = cms.vstring(), arg = cms.string(""),
nbins = cms.int32(-1), xmin = cms.int32(0), xmax = cms.int32(0)
))
return self
if sort != "MEAN":
raise Exception("Harvesting allows only reduce(MEAN) at the moment, not " + sort)
self.spec.append(cms.PSet(
type = REDUCE,
stage = self._state,
columns = cms.vstring(),
arg = cms.string(sort),
nbins = cms.int32(-1), xmin = cms.int32(0), xmax = cms.int32(0)
))
return self
def addVariable(vpset,expr,name=None,nbins=None,vmin=None,vmax=None):
if ":=" in expr:
toks=[ v.rstrip(" ").lstrip(" ") for v in expr.split(":=") ]
## print toks
name,expr=toks
if not name:
name = expr.replace(".","_").replace("get","")
if name.endswith("]"):
name,rng = name.replace("]","").split("[")
rng = rng.split(",")
nbins = int(rng[0])
vmin = float(rng[1])
vmax = float(rng[2])
if "map(" in expr:
var, bins, vals = expr.lstrip("map(").rstrip(")").split("::")
bins = [ float(b) for b in bins.split(",") ]
vals = [ float(v) for v in vals.split(",") ]
pset = cms.PSet(
expr = cms.PSet(
var = cms.string(var), bins = cms.vdouble(bins), vals = cms.vdouble(vals)
),
name = cms.untracked.string(name),
)
else:
pset = cms.PSet(
expr = cms.string(expr),
name = cms.untracked.string(name),
)
if nbins:
pset.nbins = cms.untracked.int32(nbins)
pset.vmin = cms.untracked.double(vmin)
pset.vmax = cms.untracked.double(vmax)
vpset.append(pset)
def get(todo):
defs = {}
# ZeroBias trigger configuration
defs["ZeroBiasTriggerResultsView"] = cms.PSet(
miniView = cms.string("TriggerResultsView"),
branchPrefix = cms.untracked.string("trg"),
process = cms.string("HLT"),
triggers = cms.vstring("ZeroBias"),
ZeroBias = cms.vstring("HLT_ZeroBias_part*")
)
defs["L1GTriggerResultsView"] = cms.PSet(
miniView = cms.string("TriggerResultsView"),
branchPrefix = cms.untracked.string("trgl1"),
process = cms.string("HLT"),
triggers = cms.vstring("L1GTTech","L1GTAlgo")
)
# 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 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 load_jec_from_db(process, db, algorithmes):
"""
Inform CMSSW to read the JEC from a database instead of the GT for the given list of algorithmes
"""
import os
if not os.path.isfile(db):
raise ValueError('Database %r does not exist.' % db)
if os.path.isabs(db):
raise ValueError('You cannot use an absolute for the database, as it breaks crab submission. Please put the database in the same folder as your python configuration file and pass only the filename as argument of the create function')
process.load("CondCore.DBCommon.CondDBCommon_cfi")
if verbosity:
print("Using database %r for JECs\n" % db)
process.jec = cms.ESSource("PoolDBESSource",
DBParameters = cms.PSet(
messageLevel = cms.untracked.int32(0)
),
timetype = cms.string('runnumber'),
toGet = cms.VPSet(),
connect = cms.string('sqlite:%s' % db)
)
process.gridin.input_files += [os.path.abspath(db)]
process.es_prefer_jec = cms.ESPrefer('PoolDBESSource', 'jec')
prefix = os.path.splitext(db)[0]
for algo in algorithmes:
append_jec_to_db_(process, algo, prefix)
def ageEcal(process,lumi,instLumi):
if hasattr(process,'g4SimHits'):
#these lines need to be further activiated by tuning on 'complete' aging for ecal
process.g4SimHits.ECalSD.InstLuminosity = cms.double(instLumi)
process.g4SimHits.ECalSD.DelivLuminosity = cms.double(float(lumi))
# available conditions
ecal_lumis = [300,1000,3000,4500]
ecal_conditions = [
['EcalIntercalibConstantsRcd','EcalIntercalibConstants_TL{:d}_upgrade_8deg_mc'],
['EcalIntercalibConstantsMCRcd','EcalIntercalibConstantsMC_TL{:d}_upgrade_8deg_mc'],
['EcalLaserAPDPNRatiosRcd','EcalLaserAPDPNRatios_TL{:d}_upgrade_8deg_mc'],
['EcalPedestalsRcd','EcalPedestals_TL{:d}_upgradeTIA_8deg_mc'],
['EcalTPGLinearizationConstRcd','EcalTPGLinearizationConst_TL{:d}_upgrade_8deg_mc'],
]
# try to get conditions
if int(lumi) in ecal_lumis:
if not hasattr(process.GlobalTag,'toGet'):
process.GlobalTag.toGet=cms.VPSet()
for ecal_condition in ecal_conditions:
process.GlobalTag.toGet.append(cms.PSet(
record = cms.string(ecal_condition[0]),
tag = cms.string(ecal_condition[1].format(int(lumi))),
connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS")
)
)
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
AddAntiParticle=cms.bool(False))
process.o1 = cms.OutputModule("PoolOutputModule",
process.FEVTSIMEventContent,
fileName=cms.untracked.string('simevent.root'))
process.Timing = cms.Service("Timing")
process.Tracer = cms.Service("Tracer")
process.p1 = cms.Path(process.generator * process.VtxSmeared *
process.g4SimHits)
process.outpath = cms.EndPath(process.o1)
process.TFileService = cms.Service(
"TFileService", fileName=cms.string('PionHcalTestAnalysis.root'))
process.g4SimHits.Physics.type = 'SimG4Core/Physics/QGSP_BERT_EML'
process.g4SimHits.G4Commands = ['/tracking/verbose 1']
process.common_maximum_timex = cms.PSet(
MaxTrackTime=cms.double(1000.0),
MaxTimeNames=cms.vstring(),
MaxTrackTimes=cms.vdouble(),
DeadRegions=cms.vstring(),
CriticalEnergyForVacuum=cms.double(2.0),
CriticalDensity=cms.double(1e-15))
process.g4SimHits.StackingAction = cms.PSet(
process.common_heavy_suppression,
process.common_maximum_timex,
TrackNeutrino=cms.bool(False),
KillDeltaRay=cms.bool(False),
process.EnableFloatingPointExceptions = cms.Service("EnableFloatingPointExceptions")
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
generator = cms.PSet(
initialSeed = cms.untracked.uint32(123456789),
engineName = cms.untracked.string('HepJamesRandom')
),
VtxSmeared = cms.PSet(
engineName = cms.untracked.string('HepJamesRandom'),
initialSeed = cms.untracked.uint32(98765432)
),
g4SimHits = cms.PSet(
initialSeed = cms.untracked.uint32(11),
engineName = cms.untracked.string('HepJamesRandom')
)
)
process.load('SimG4Core.Application.g4SimHits_cfi')
process.p1 = cms.Path(process.generator*process.VtxSmeared*process.generatorSmeared*process.g4SimHits)
process.g4SimHits.Physics.type = 'SimG4Core/Physics/DummyPhysics'
process.g4SimHits.UseMagneticField = False
process.g4SimHits.Physics.DummyEMPhysics = True
process.g4SimHits.Physics.DefaultCutValue = 10.
process.g4SimHits.Watchers = cms.VPSet(cms.PSet(
Name = cms.untracked.string('TIDF'),
type = cms.string('PrintMaterialBudgetInfo')
))
"topPairEPlusJetsSelection",
'TopPairElectronPlusJetsSelection.signalElectron', 'PAT'),
muon_input=cms.InputTag("topPairMuPlusJetsSelection",
'TopPairMuonPlusJetsSelection.signalMuon', 'PAT'),
vertex_input=cms.InputTag('goodOfflinePrimaryVertices'),
gen_event_input=cms.InputTag('genEvt'),
selection_flag_input=cms.InputTag(
"topPairEPlusJetsSelection",
'TopPairElectronPlusJetsSelection.FullSelection', 'PAT'),
is_fully_hadronic_flag=cms.InputTag('ttFullHadronicFilter'),
is_dileptonic_flag=cms.InputTag('ttFullLeptonicFilter'),
is_semileptonic_tau_flag=cms.InputTag('ttSemiLeptonicTauFilter'),
is_semileptonic_electron_flag=cms.InputTag('ttSemiLeptonicElectronFilter'),
is_semileptonic_muon_flag=cms.InputTag('ttSemiLeptonicMuonFilter'),
do_electron_channel=cms.untracked.bool(True),
variable_under_analysis=cms.string('MET'),
variable_min=cms.double(variable_bins['MET']['min']),
variable_max=cms.double(variable_bins['MET']['max']),
variable_n_bins=cms.uint32(variable_bins['MET']['n_bins']),
bin_edges=cms.vdouble([0, 25, 45, 70, 100, 150, 2000]),
centre_of_mass_energy=cms.double(8),
)
unfolding_MET_analyser_muon_channel_patMETsPFlow = unfolding_MET_analyser_electron_channel_patMETsPFlow.clone(
do_electron_channel=cms.untracked.bool(False), )
unfolding_MET_nu_analyser_electron_channel_patMETsPFlow = unfolding_MET_analyser_electron_channel_patMETsPFlow.clone(
variable_under_analysis=cms.string('MET_nu'), )
unfolding_MET_nu_analyser_muon_channel_patMETsPFlow = unfolding_MET_nu_analyser_electron_channel_patMETsPFlow.clone(
do_electron_channel=cms.untracked.bool(False), )
import FWCore.ParameterSet.Config as cms
from RecoJets.JetProducers.GenJetParameters_cfi import *
from RecoJets.JetProducers.AnomalousCellParameters_cfi import *
iterativeCone5GenJets = cms.EDProducer(
"FastjetJetProducer",
GenJetParameters,
AnomalousCellParameters,
jetAlgorithm=cms.string("IterativeCone"),
rParam=cms.double(0.5))
from Configuration.Eras.Modifier_fastSim_cff import fastSim
# NEW CLUSTERS (remove previously used clusters)
pixelPairStepClusters = _cfg.clusterRemoverForIter("PixelPairStep")
for _eraName, _postfix, _era in _cfg.nonDefaultEras():
_era.toReplaceWith(pixelPairStepClusters, _cfg.clusterRemoverForIter("PixelPairStep", _eraName, _postfix))
# SEEDING LAYERS
pixelPairStepSeedLayers = cms.EDProducer("SeedingLayersEDProducer",
layerList = cms.vstring('BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3',
'BPix1+FPix1_pos', 'BPix1+FPix1_neg',
'BPix2+FPix1_pos', 'BPix2+FPix1_neg',
'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg'),
BPix = cms.PSet(
TTRHBuilder = cms.string('WithTrackAngle'),
HitProducer = cms.string('siPixelRecHits'),
skipClusters = cms.InputTag('pixelPairStepClusters')
),
FPix = cms.PSet(
TTRHBuilder = cms.string('WithTrackAngle'),
HitProducer = cms.string('siPixelRecHits'),
skipClusters = cms.InputTag('pixelPairStepClusters')
)
)
# layers covering the region not covered by quadruplets (so it is
# just acting as backup of triplets)
_layerListForPhase1 = [
'BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3',
'BPix1+FPix1_pos', 'BPix1+FPix1_neg',
'BPix2+FPix1_pos', 'BPix2+FPix1_neg',
process.load('Configuration.StandardSequences.GeometryDB_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_cff')
process.load('Configuration.StandardSequences.ReconstructionHeavyIons_cff')
process.load('Configuration.StandardSequences.EndOfProcess_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.load('Appeltel.HIRun2015Ana.HITrackProfiler_cfi')
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(1)
)
process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True))
process.TFileService = cms.Service("TFileService",
fileName = cms.string('trackProfiler.root')
)
process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi")
process.tpRecoAssocGeneralTracks = process.trackingParticleRecoTrackAsssociation.clone()
process.tpRecoAssocGeneralTracks.label_tr = cms.InputTag("TrackRefitter")
process.load("SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi")
process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco')
process.quickTrackAssociatorByHits.Cut_RecoToSim = 0.02
process.quickTrackAssociatorByHits.Quality_SimToReco = 0.02
process.quickTrackAssociatorByHits.Purity_SimToReco = 0.02
process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi")
process.DiMuFilter= cms.EDFilter("DiMuonFilter",
vertex=cms.InputTag("offlineSlimmedPrimaryVertices"),
muonSrc =cms.InputTag("slimmedMuons"),
bits = cms.InputTag("TriggerResults","","HLT"),
objects = cms.InputTag("slimmedPatTrigger"),
trigNames = cms.vstring("HLT_IsoMu27_v","HLT_IsoTkMu27_v","HLT_IsoMu24_v","HLT_IsoTkMu24_v"),
)
#################################################################################################
process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) )
process.TFileService = cms.Service("TFileService",
fileName = cms.string('file:TauEfficiency_MuonAllID_mA20_OldTauID.root')
)
process.p_l = cms.Path(process.GenModeFilterMu*process.DiMuFilter*process.ThirdMuFilter*process.MuEffLoose*process.TauEffDModeLoose*process.TauEffMDModeLoose);
process.p_m = cms.Path(process.GenModeFilterMu*process.DiMuFilter*process.ThirdMuFilterMedium*process.MuEffMedium*process.TauEffDModeMedium*process.TauEffMDModeMedium);
process.p_t = cms.Path(process.GenModeFilterMu*process.DiMuFilter*process.ThirdMuFilterTight*process.MuEffTight*process.TauEffDModeTight*process.TauEffMDModeTight);
process.schedule=cms.Schedule(process.p_l,process.p_m,process.p_t)
import FWCore.ParameterSet.Config as cms
slimmedMuons = cms.EDProducer(
"PATMuonSlimmer",
src=cms.InputTag("selectedPatMuons"),
linkToPackedPFCandidates=cms.bool(True),
pfCandidates=cms.VInputTag(cms.InputTag("particleFlow")),
packedPFCandidates=cms.VInputTag(cms.InputTag("packedPFCandidates")),
saveTeVMuons=cms.string(
"pt > 100"), # you can put a cut to slim selectively, e.g. pt > 10
dropDirectionalIso=cms.string("0"),
dropPfP4=cms.string("1"),
slimCaloVars=cms.string("1"),
slimKinkVars=cms.string("1"),
slimCaloMETCorr=cms.string("1"),
slimMatches=cms.string("1"),
segmentsMuonSelection=cms.string(
"pt > 50"
), #segments are needed for EXO analysis looking at TOF and for very high pt from e.g. Z'
saveSegments=cms.bool(True),
modifyMuons=cms.bool(True),
modifierConfig=cms.PSet(modifications=cms.VPSet()))
import FWCore.ParameterSet.Config as cms
process = cms.Process("DQM")
# DQM service
process.load("DQMServices.Core.DQMStore_cfi")
# MessageLogger
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
# Global Tag
from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag as customiseGlobalTag
process.GlobalTag = customiseGlobalTag(globaltag='80X_dataRun2_HLT_v12')
process.GlobalTag.connect = cms.string(
'frontier://FrontierProd/CMS_CONDITIONS')
# Source
process.source = cms.Source(
"PoolSource",
fileNames=cms.untracked.vstring(
'/store/data/Run2016B/HLTPhysics2/RAW/v1/000/272/022/00000/4CE23DEB-CB0D-E611-A6AC-02163E01181C.root'
))
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1000))
# unpack L1 digis
process.load("EventFilter.L1TRawToDigi.gtStage2Digis_cfi")
process.gtStage2Digis.InputLabel = cms.InputTag("rawDataCollector")
process.load("DQM.HLTEvF.triggerBxMonitor_cfi")
process.triggerBxMonitor.l1tResults = cms.untracked.InputTag('gtStage2Digis')
import FWCore.ParameterSet.Config as cms
# link to cards:
# https://github.com/cms-sw/genproductions/tree/afad53082a334f6e6ad4a3769124ccc50b8e8991/bin/MadGraph5_aMCatNLO/cards/production/13TeV/exo_diboson/Spin-1/Wprime_Wh_Whadhtata/Wprime_Wh_Whadhtata_narrow_M1400
externalLHEProducer = cms.EDProducer(
"ExternalLHEProducer",
args=cms.vstring(
'/cvmfs/cms.cern.ch/phys_generator/gridpacks/slc6_amd64_gcc481/13TeV/madgraph/V5_2.2.2/exo_diboson/Spin-1/Wprime_Wh_Whadhtata/narrow/v1/Wprime_Wh_Whadhtata_narrow_M1400_tarball.tar.xz'
),
nEvents=cms.untracked.uint32(5000),
numberOfParameters=cms.uint32(1),
outputFile=cms.string('cmsgrid_final.lhe'),
scriptName=cms.FileInPath(
'GeneratorInterface/LHEInterface/data/run_generic_tarball_cvmfs.sh'))
initL1O2OTagsExt()
if options.keysFromDB == 1:
process.load("CondTools.L1TriggerExt.L1ConfigRSKeysExt_cff")
else:
process.load("CondTools.L1TriggerExt.L1TriggerKeyDummyExt_cff")
from CondTools.L1TriggerExt.L1RSSubsystemParamsExt_cfi import initL1RSSubsystemsExt
initL1RSSubsystemsExt( tagBaseVec = initL1O2OTagsExt.tagBaseVec )
process.L1TriggerKeyDummyExt.objectKeys = initL1RSSubsystemsExt.params.recordInfo
# Get L1TriggerKeyListExt from DB
process.load("CondCore.DBCommon.CondDBCommon_cfi")
process.outputDB = cms.ESSource("PoolDBESSource",
process.CondDBCommon,
toGet = cms.VPSet(cms.PSet(
record = cms.string('L1TriggerKeyListExtRcd'),
tag = cms.string('L1TriggerKeyListExt_' + initL1O2OTagsExt.tagBaseVec[ L1CondEnumExt.L1TriggerKeyListExt ] )
))
)
process.outputDB.connect = options.outputDBConnect
process.outputDB.DBParameters.authenticationPath = options.outputDBAuth
# writer modules
from CondTools.L1TriggerExt.L1CondDBIOVWriterExt_cff import initIOVWriterExt
initIOVWriterExt( process,
outputDBConnect = options.outputDBConnect,
outputDBAuth = options.outputDBAuth,
tagBaseVec = initL1O2OTagsExt.tagBaseVec,
tscKey = '' )
process.L1CondDBIOVWriterExt.logKeys = True
process = cms.Process("RECO2")
process.load('Configuration.StandardSequences.Services_cff')
process.load('FWCore.MessageService.MessageLogger_cfi')
process.load('Configuration.EventContent.EventContent_cff')
process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
process.load('Configuration.Geometry.GeometrySimDB_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_PostLS1_cff')
process.load('Configuration.StandardSequences.EndOfProcess_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.load('Configuration.StandardSequences.RawToDigi_cff')
process.load('Configuration.StandardSequences.Reconstruction_cff')
process.GlobalTag.globaltag = 'POSTLS172_V1::All'
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("GeometryFileRcd"),
tag = cms.string("XMLFILE_Geometry_2015_72YV2_Extended2015ZeroMaterial_mc"),
connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_GEOMETRY_000"),
# label = cms.untracked.string("Extended2015ZeroMaterial")
),
cms.PSet(record = cms.string("EcalTBWeightsRcd"),
tag = cms.string("EcalTBWeights_3p5_time_mc"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL")
)
)
#### CONFIGURE IT HERE
isMC = True
#####################
process.MessageLogger.cerr.FwkReport.reportEvery = 1
import FWCore.ParameterSet.Config as cms
process = cms.Process("ANALYSIS")
process.load("Configuration.StandardSequences.Services_cff")
process.load("Configuration.StandardSequences.Reconstruction_cff")
process.load("Configuration.StandardSequences.RawToDigi_Data_cff")
process.load(
"Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
process.GlobalTag.globaltag = cms.string('GR09_P_V8_34X::All')
process.load("Configuration.StandardSequences.Geometry_cff")
process.load("Configuration.StandardSequences.MagneticField_cff")
#process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.load("DQM.SiStripCommon.MessageLogger_cfi")
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))
process.source = cms.Source(
"PoolSource",
fileNames=cms.untracked.vstring(
#'/store/data/BeamCommissioning09/MinimumBias/RECO/v2/000/124/009/A81DC948-A2E6-DE11-AF25-000423D94524.root',
'/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0100/965030FF-3DE9-DE11-B75B-00151796C18C.root',
'/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0100/485EDF6C-48E9-DE11-BE46-0024E876841F.root',
'/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0100/3EAFDE66-71E9-DE11-B861-0024E876A814.root',
'/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0099/A683E072-22E9-DE11-B396-001D0967DA6C.root',
'/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0099/5E275AD5-35E9-DE11-96BA-00151796D884.root',
'/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0099/04E1641C-2AE9-DE11-A073-001D0967CFCC.root'
),
#skipEvents = cms.untracked.uint32(0)
#eventsToProcess = cms.untracked.VEventRange('124009:10872958-124009:10872958')
eventsToProcess=cms.untracked.VEventRange('124120:542515-124120:542515'))
muons = cms.InputTag("slimmedMuons"),
electrons = cms.InputTag("slimmedElectrons"),
taus = cms.InputTag("slimmedTaus"),
photons = cms.InputTag("slimmedPhotons"),
jets = cms.InputTag("slimmedJets"),
fatjets = cms.InputTag("slimmedJetsAK8"),
mets = cms.InputTag("slimmedMETs"),
pfCands = cms.InputTag("packedPFCandidates"),
packed = cms.InputTag("packedGenParticles"),
pruned = cms.InputTag("prunedGenParticles"),
bits = cms.InputTag("TriggerResults","","HLT"),
prescales = cms.InputTag("patTrigger")
)
process.TFileService = cms.Service("TFileService",
fileName = cms.string("ttbar407.root"),
closeFileFast = cms.untracked.bool(True)
)
###############################################
# RECO AND GEN SETUP
process.load('PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff')
process.load('Configuration.EventContent.EventContent_cff')
process.load('Configuration.StandardSequences.Geometry_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag ='PHYS14_25_V2'
#'START70_V6::All'
#'START70_V6::All'
process.load('RecoJets.Configuration.RecoPFJets_cff')
if chsorpuppi:
process.goodAK4Jets.src = "slimmedJets"
else:
process.goodAK4Jets.src = "slimmedJetsPuppi"
#process.goodOfflinePrimaryVertex = cms.EDFilter("VertexSelector",
# src = cms.InputTag("offlineSlimmedPrimaryVertices"),
# cut = cms.string("chi2!=0 && ndof >= 4.0 && abs(z) <= 24.0 && abs(position.Rho) <= 2.0"),
# filter = cms.bool(False)
# )
ZBOSONCUT = "pt > 0.0"
process.leptonicVSelector = cms.EDFilter("CandViewSelector",
src=cms.InputTag("leptonicV"),
cut=cms.string(ZBOSONCUT),
filter=cms.bool(False))
process.leptonicVFilter = cms.EDFilter("CandViewCountFilter",
src=cms.InputTag("leptonicV"),
minNumber=cms.uint32(0),
filter=cms.bool(False))
process.leptonSequence = cms.Sequence(process.muSequence +
process.eleSequence +
process.leptonicVSequence +
process.leptonicVSelector +
process.leptonicVFilter)
process.jetSequence = cms.Sequence(process.NJetsSequence)
from cp3_llbb.Framework import METProducer
from cp3_llbb.Framework.CmdLine import CmdLine
options = CmdLine()
runOnData = options.runOnData == 1
globalTag_ = '80X_mcRun2_asymptotic_2016_TrancheIV_v8'
processName_ = 'PAT'
if runOnData :
globalTag_ = '80X_dataRun2_2016SeptRepro_v7'
processName_ = 'RECO'
framework = Framework.Framework(runOnData, eras.Run2_25ns, globalTag=globalTag_, processName=processName_)
framework.addAnalyzer('hh_analyzer', cms.PSet(
type = cms.string('hh_analyzer'),
prefix = cms.string('hh_'),
enable = cms.bool(True),
categories_parameters = cms.PSet(
# Per-category lepton pt cuts
mumu_leadingLeptonPtCut = cms.untracked.double(20), # muon
mumu_subleadingLeptonPtCut = cms.untracked.double(10), # muon
elel_leadingLeptonPtCut = cms.untracked.double(25), # electron
elel_subleadingLeptonPtCut = cms.untracked.double(15), # electron
muel_leadingLeptonPtCut = cms.untracked.double(25), # muon
muel_subleadingLeptonPtCut = cms.untracked.double(15), # electron
elmu_leadingLeptonPtCut = cms.untracked.double(25), # electron
elmu_subleadingLeptonPtCut = cms.untracked.double(10), # muon
),
parameters = cms.PSet(
# Producers
import FWCore.ParameterSet.Config as cms
from CondCore.DBCommon.CondDBSetup_cfi import *
RerecoGlobalTag = cms.ESSource("PoolDBESSource",
CondDBSetup,
connect = cms.string('frontier://FrontierProd/CMS_COND_31X_GLOBALTAG'),
# globaltag = cms.string('UNSPECIFIED::All'),
globaltag = cms.string('GR_R_42_V24::All'),
#toGet = cms.VPSet( ), # hook to override or add single payloads
toGet = cms.VPSet(
cms.PSet(record = cms.string("EcalIntercalibConstantsRcd"),
tag = cms.string("EcalIntercalibConstants_2011_V1"),
connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_31X_ECAL")
),
# ,cms.PSet(record = cms.string("EcalADCToGeVConstantRcd"),
# tag = cms.string("EcalADCToGeVConstant_v10_offline"),
# connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_31X_ECAL")
# )
# ,
cms.PSet(record = cms.string("EcalLaserAPDPNRatiosRcd"),
tag = cms.string("EcalLaserAPDPNRatios_data_20120131_158851_183320"),
connect = cms.untracked.string("frontier://FrontierInt/CMS_COND_ECAL")
),
#
cms.PSet(record = cms.string('EcalLaserAlphasRcd'),
tag = cms.string('EcalLaserAlphas_eflow_EBperchan_EEperchanDelta'),
connect = cms.untracked.string('frontier://FrontierInt/CMS_COND_ECAL')
)
),
BlobStreamerName = cms.untracked.string('TBufferBlobStreamingService')
'''
import FWCore.ParameterSet.Config as cms
import os
# rootfile_dir = os.environ['CMSSW_BASE'] + '/src/CMGTools/H2TauTau/data/metRecoilCorrection/'
rootfile_dir = os.environ['CMSSW_BASE'] + '/src/CMGTools/Utilities/data/metRecoilCorrection/'
recoilCorrectedMETDiTau2012 = cms.EDProducer(
"RecoilCorrectedMETProducer2012DiTau",
metSrc = cms.InputTag('cmgPFMET'),
# the tau is on the first leg and the muon on the second leg
recBosonSrc = cms.InputTag('cmgDiTauSel'),
genBosonSrc = cms.InputTag('genWorZ'),
jetSrc = cms.InputTag('cmgPFJetForRecoil'),
# 1: lepton is on leg1; 2: lepton is on leg2;
# 0: take both legs as leptons, and sum them up
leptonLeg = cms.int32(0),
# 1: type 1; 2 : type 2; 0 : all (use 1)
correctionType = cms.int32(2),
#fileCorrectTo = cms.string(rootfile_dir + 'recoilfit_htt53X_20pv_njet.root'),
fileCorrectTo = cms.string(rootfile_dir + 'recoilfit_ztt53X_20pv_njet.root'),
# you should not have to change the files below
fileZmmData = cms.string(rootfile_dir + 'recoilfit_datamm53X_20pv_njet.root'),
fileZmmMC = cms.string(rootfile_dir + 'recoilfit_zmm53X_20pv_njet.root'),
enable = cms.bool(True),
force = cms.bool(False),
verbose = cms.untracked.bool( False )
#COLIN: make delta R a parameter
)
'JetMatching:nQmatch = 5', #4 corresponds to 4-flavour scheme (no matching of b-quarks), 5 for 5-flavour scheme
'JetMatching:nJetMax = 2', #number of partons in born matrix element for highest multiplicity
'JetMatching:doShowerKt = off', #off for MLM matching, turn on for shower-kT matching
'6:m0 = 172.5',
'Check:abortIfVeto = on',
'ResonanceDecayFilter:filter = on',
'ResonanceDecayFilter:exclusive = off', #off: require at least the specified number of daughters, on: require exactly the specified number of daughters
'ResonanceDecayFilter:eMuAsEquivalent = off', #on: treat electrons and muons as equivalent
'ResonanceDecayFilter:eMuTauAsEquivalent = on', #on: treat electrons, muons , and taus as equivalent
'ResonanceDecayFilter:allNuAsEquivalent = on', #on: treat all three neutrino flavours as equivalent
#'ResonanceDecayFilter:mothers =', #list of mothers not specified -> count all particles in hard process+resonance decays (better to avoid specifying mothers when including leptons from the lhe in counting, since intermediate resonances are not gauranteed to appear in general
'ResonanceDecayFilter:daughters = 11',
# '23:mMin = 0.1',
'24:mMin = 0.1',
),
parameterSets = cms.vstring('pythia8CommonSettings',
'pythia8CUEP8M1Settings',
'JetMatchingParameters'
)
)
generator.RandomizedParameters.append(
cms.PSet(
ConfigWeight = cms.double(wgt),
GridpackPath = cms.string('/cvmfs/cms.cern.ch/phys_generator/gridpacks/slc6_amd64_gcc481/13TeV/madgraph/V5_2.3.3/sus_sms/SMS-SqSq/SMS-SqSq_mSq-%i_tarball.tar.xz' % msq),
ConfigDescription = cms.string('%s_%i_%i' % (model, msq, mlsp)),
SLHATableForPythia8 = cms.string('%s' % slhatable),
PythiaParameters = basePythiaParameters,
),
)
#process.load("Configuration.Geometry.GeometryIdeal_cff" )
process.load("Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff" )
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff')
from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag
#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_data', '')
process.GlobalTag = GlobalTag(process.GlobalTag, '76X_dataRun2_16Dec2015_v0')
#process.Tracer = cms.Service("Tracer")
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100000) )
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
#jec from sqlite
process.load("CondCore.DBCommon.CondDBCommon_cfi")
from CondCore.DBCommon.CondDBSetup_cfi import *
process.jec = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = cms.string('sqlite:Fall15_25nsV2_DATA.db'),
toGet = cms.VPSet(
cms.PSet(
record = cms.string('JetCorrectionsRecord'),
tag = cms.string('JetCorrectorParametersCollection_Fall15_25nsV2_DATA_AK4PFchs'),
label = cms.untracked.string('AK4PFchs')
),
cms.PSet(
record = cms.string('JetCorrectionsRecord'),
tag = cms.string('JetCorrectorParametersCollection_Fall15_25nsV2_DATA_AK8PFchs'),
label = cms.untracked.string('AK8PFchs')
)))
process.es_prefer_jec = cms.ESPrefer('PoolDBESSource','jec')
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring(
# HTXS ========================================================================================================
if not isData and isHiggsSignal:
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
process.mergedGenParticles = cms.EDProducer("MergedGenParticleProducer",
inputPruned = cms.InputTag("prunedGenParticles"),
inputPacked = cms.InputTag("packedGenParticles"),
)
process.myGenerator = cms.EDProducer("GenParticles2HepMCConverter",
genParticles = cms.InputTag("mergedGenParticles"),
genEventInfo = cms.InputTag("generator"),
signalParticlePdgIds = cms.vint32(25),
)
process.rivetProducerHTXS = cms.EDProducer('HTXSRivetProducer',
HepMCCollection = cms.InputTag('myGenerator','unsmeared'),
LHERunInfo = cms.InputTag('externalLHEProducer'),
ProductionMode = cms.string('AUTO'),
)
process.htxsSequence = cms.Sequence( process.mergedGenParticles * process.myGenerator * process.rivetProducerHTXS )
else :
process.htxsSequence = cms.Sequence( )
# END HTXS ====================================================================================================
# Pre-firing weights ==========================================================================================
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/L1ECALPrefiringWeightRecipe
from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer
if period == "2018" :
process.prefiringweight = cms.Sequence()
else:
if period == '2016' :
data_era = "2016BtoH"
process.SiStripCondObjBuilderFromDb.SiStripDetInfoFile = cms.FileInPath(
"CalibTracker/SiStripCommon/data/SiStripDetInfo.dat")
process.SiStripCondObjBuilderFromDb.UseAnalysis = True
process.load("CondCore.DBCommon.CondDBCommon_cfi")
process.CondDBCommon.connect = 'sqlite_file:dbfile.db'
process.CondDBCommon.DBParameters.messageLevel = 4
process.CondDBCommon.DBParameters.authenticationPath = '/afs/cern.ch/cms/DB/conddb'
process.PoolDBOutputService = cms.Service(
"PoolDBOutputService",
process.CondDBCommon,
BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'),
logconnect=cms.untracked.string('sqlite_file:log.db'),
timetype=cms.untracked.string('runnumber'),
toPut=cms.VPSet(
cms.PSet(record=cms.string('SiStripApvGainRcd'),
tag=cms.string('SiStripApvGain_test'))))
process.CommonSiStripPopConParams = cms.PSet(
SinceAppendMode=cms.bool(True),
Source=cms.PSet(since=cms.untracked.uint32(1),
name=cms.untracked.string('default'),
debug=cms.untracked.bool(True)),
loggingOn=cms.untracked.bool(True))
process.siStripPopConApvGain = cms.EDAnalyzer(
"SiStripPopConApvGain",
process.CommonSiStripPopConParams,
record=cms.string('SiStripApvGainRcd'))
process.siStripPopConApvGain.Source.name = 'siStripPopConApvGain'
import FWCore.ParameterSet.Config as cms
gemDigiValidation = cms.EDAnalyzer(
'MuonGEMDigis',
outputFile=cms.string(''),
stripLabel=cms.InputTag('simMuonGEMDigis'),
cscPadLabel=cms.InputTag('simMuonGEMCSCPadDigis'),
cscCopadLabel=cms.InputTag('simMuonGEMCSCPadDigis', 'Coincidence'),
simInputLabel=cms.InputTag('g4SimHits', "MuonGEMHits"),
PlotBinInfo=cms.PSet(
nBinGlobalZR=cms.untracked.vdouble(200, 200, 200, 150, 180, 250),
RangeGlobalZR=cms.untracked.vdouble(564, 572, 786, 794, 794, 802, 110,
260, 170, 350, 100, 350),
nBinGlobalXY=cms.untracked.int32(360),
GE11PhiBegin=cms.untracked.double(-5),
GE11PhiStep=cms.untracked.double(10),
),
simTrackMatching=cms.PSet(
#simInputLabel = cms.InputTag('g4SimHits',"MuonGEMHits"),
simTrackCollection=cms.InputTag('g4SimHits'),
simVertexCollection=cms.InputTag('g4SimHits'),
verboseSimHit=cms.untracked.int32(0),
# GEM digi matching:
verboseGEMDigi=cms.untracked.int32(0),
gemDigiInput=cms.untracked.InputTag("simMuonGEMDigis"),
gemPadDigiInput=cms.untracked.InputTag("simMuonGEMCSCPadDigis"),
gemCoPadDigiInput=cms.untracked.InputTag("simMuonGEMCSCPadDigis",
"Coincidence"),
minBXGEM=cms.untracked.int32(-1),
maxBXGEM=cms.untracked.int32(1),
matchDeltaStripGEM=cms.untracked.int32(1),
import FWCore.ParameterSet.Config as cms
from RecoParticleFlow.PFClusterProducer.particleFlowCaloResolution_cfi import _timeResolutionHCAL
_thresholdsHB = cms.vdouble(0.8, 0.8, 0.8, 0.8)
_thresholdsHE = cms.vdouble(0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8)
_thresholdsHBphase1 = cms.vdouble(0.1, 0.2, 0.3, 0.3)
_thresholdsHEphase1 = cms.vdouble(0.1, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2)
particleFlowRecHitHBHE = cms.EDProducer("PFRecHitProducer",
navigator = cms.PSet(
name = cms.string("PFRecHitHCALNavigator"),
sigmaCut = cms.double(4.0),
timeResolutionCalc = _timeResolutionHCAL
),
producers = cms.VPSet(
cms.PSet(
name = cms.string("PFHBHERecHitCreator"),
src = cms.InputTag("hbhereco",""),
qualityTests = cms.VPSet(
cms.PSet(
name = cms.string("PFRecHitQTestHCALThresholdVsDepth"),
cuts = cms.VPSet(
cms.PSet(
depth=cms.vint32(1, 2, 3, 4),
threshold = _thresholdsHB,
detectorEnum = cms.int32(1)
),
cms.PSet(
depth=cms.vint32(1, 2, 3, 4, 5, 6, 7),
threshold = _thresholdsHE,
BusyInputSectorNumStubs = cms.uint32(175), # Naive value is 210.
#BusyInputSectorNumStubs = cms.uint32(120), # Alternative proposal from Tom James for ultra compact firmware.
# Multiplex the outputs from several HTs onto a single pair of output optical links?
# Options: 0 = disable Mux; 1 = Dec. 2016 Mux; 2 = Mar 2018 Mux (for transverse HT readout by m-bin).
# (The mux algorithm is hard-wired in class MuxHToutputs, and currently only works if option BusySectorMbinRanges is being used).
MuxOutputsHT = cms.uint32(2),
# If this is non-empty, then only the specified eta sectors are enabled, to study them individually.
EtaRegWhitelist = cms.vuint32()
),
#=== Options controlling r-z track filters (or any other track filters run after the Hough transform, as opposed to inside it).
#=== (Irrelevant for track fitters that don't require any r-z filter run before them).
RZfilterOpts = cms.PSet(
# Specify preferred r-z filter (from those available inside TrkRZfilter.cc) - currently only "SeedFilter".
RZFilterName = cms.string("SeedFilter"),
#--- Options relevant for Seed filter, (so only relevant if rzFilterName="SeedFilter").
# Added resolution beyond that estimated from hit resolution.
SeedResolution = cms.double(0.),
# Store stubs compatible with all possible good seed.
KeepAllSeed = cms.bool(False),
# Maximum number of seed combinations to bother checking per track candidate.
#MaxSeedCombinations = cms.uint32(999),
MaxSeedCombinations = cms.uint32(15),
# Maximum number of seed combinations consistent with (z0,eta) sector constraints to bother checking per track candidate.
#MaxGoodSeedCombinations = cms.uint32(13),
MaxGoodSeedCombinations = cms.uint32(10),
# Maximum number of seeds that a single stub can be included in.
MaxSeedsPerStub = cms.uint32(4),
# Reject tracks whose estimated rapidity from seed filter is inconsistent range of with eta sector. (Kills some duplicate tracks).
zTrkSectorCheck = cms.bool(True),
2.06042305E-06 2 24 35 # BR(Hp -> W HH)
3.51688173E-06 2 24 36 # BR(Hp -> W A0)
DECAY 6 1.37127534E+00 # Gamma(top)
1.00000000E+00 2 5 24 # BR(top -> bottom W)
"""
import FWCore.ParameterSet.Config as cms
from Configuration.Generator.Pythia8CommonSettings_cfi import *
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *
generator = cms.EDFilter("Pythia8GeneratorFilter",
pythiaPylistVerbosity = cms.untracked.int32(1),
filterEfficiency = cms.untracked.double(1),
pythiaHepMCVerbosity = cms.untracked.bool(False),
SLHATableForPythia8 = cms.string('%s' % SLHA_TABLE),
comEnergy = cms.double(COM_ENERGY),
crossSection = cms.untracked.double(CROSS_SECTION),
maxEventsToPrint = cms.untracked.int32(1),
PythiaParameters = cms.PSet(
pythia8CommonSettingsBlock,
pythia8CUEP8M1SettingsBlock,
processParameters = cms.vstring(
'Higgs:useBSM = on',
PROCESS,
'SLHA:allowUserOverride = off',
'SLHA:minMassSM = 100.',
'PhaseSpace:mHatMin = 56.0'
),
parameterSets = cms.vstring(
'pythia8CommonSettings',
import FWCore.ParameterSet.Config as cms
from FWCore.MessageLogger.MessageLogger_cfi import *
process = cms.Process("MF")
process.load("Configuration.StandardSequences.GeometryExtended_cff")
process.load("Configuration.StandardSequences.MagneticField_38T_cff")
process.XMLIdealGeometryESSource = cms.ESSource("XMLIdealGeometryESSource",
geomXMLFiles = cms.vstring('Geometry/CMSCommonData/data/normal/cmsextent.xml',
'Geometry/CMSCommonData/data/cms.xml',
'Geometry/CMSCommonData/data/cmsMagneticField.xml',
'MagneticField/GeomBuilder/data/MagneticFieldVolumes_160812_1.xml',
'MagneticField/GeomBuilder/data/MagneticFieldVolumes_160812_2.xml',
'Geometry/CMSCommonData/data/materials.xml'),
rootNodeName = cms.string('cms:MCMS')
)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(1)
)
process.source = cms.Source("EmptySource")
process.prod = cms.EDProducer("GeometryProducer",
MagneticField = cms.PSet(delta = cms.double(1.0)),
UseMagneticField = cms.bool(False),
UseSensitiveDetectors = cms.bool(False)
)
process.add_(cms.ESProducer("TGeoMgrFromDdd",
verbose = cms.untracked.bool(False),
sys.path.insert(0, 'XMuMuAnalysis/NanoAODAnalyzer/scripts/')
from ProcNanoAODSkim_Common import *
#
# Basic Configuration
#
era = "2017"
debug = False
nevents = -1
#
#
# ParameterSets for use in bin/<script>.cc
#
process = cms.PSet()
#
# LumiMask
#
process.inputs = cms.PSet(lumisToProcess=CfgTypes.untracked(
CfgTypes.VLuminosityBlockRange()), )
#
#
#
process.ProcessNanoAOD_XMuMu = cms.PSet(
debug=cms.bool(debug),
maxEvents=cms.int32(int(nevents)),
inputListDir=cms.string(inputListDir_2018),
outputListDir=cms.string(outputListDir),
era=cms.string(era),
blind=cms.bool(False),
isMC=cms.bool(True),
)
# \author Maria Teresa Grippo (University of Siena, INFN Pisa)
#
# Copyright 2011-2013 Subir Sarkar, Rosamaria Venditti (INFN Bari, Bari University)
# Copyright 2014 Konstantin Androsov <*****@*****.**>,
# Maria Teresa Grippo <*****@*****.**>
#
# This file is part of X->HH->bbTauTau.
#
# X->HH->bbTauTau is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# X->HH->bbTauTau is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with X->HH->bbTauTau. If not, see <http://www.gnu.org/licenses/>.
import FWCore.ParameterSet.Config as cms
muonBlock = cms.EDAnalyzer(
"MuonBlock",
muonSrc=cms.InputTag('patMuonsWithEmbeddedVariables'),
vertexSrc=cms.InputTag('patVertices'),
offlineBeamSpot=cms.InputTag('offlineBeamSpot'),
beamSpotCorr=cms.bool(True),
muonID=cms.string('GlobalMuonPromptTight'))
'90X_upgrade2017_realistic_v20', '')
process.generator = cms.EDFilter(
"Pythia8PtGun",
PGunParameters=cms.PSet(AddAntiParticle=cms.bool(True),
MaxEta=cms.double(2.5),
MaxPhi=cms.double(3.14159265359),
MaxPt=cms.double(10.01),
MinEta=cms.double(-2.5),
MinPhi=cms.double(-3.14159265359),
MinPt=cms.double(9.99),
ParticleID=cms.vint32(211)),
PythiaParameters=cms.PSet(parameterSets=cms.vstring()),
Verbosity=cms.untracked.int32(0),
firstRun=cms.untracked.uint32(1),
psethack=cms.string('single pi pt 10'))
# Path and EndPath definitions
process.generation_step = cms.Path(process.pgen)
process.simulation_step = cms.Path(process.psim)
process.digitisation_step = cms.Path(process.pdigi_valid)
process.L1simulation_step = cms.Path(process.SimL1Emulator)
process.digi2raw_step = cms.Path(process.DigiToRaw)
process.raw2digi_step = cms.Path(process.RawToDigi)
process.reconstruction_step = cms.Path(process.reconstruction)
process.genfiltersummary_step = cms.EndPath(process.genFilterSummary)
process.endjob_step = cms.EndPath(process.endOfProcess)
process.FEVTDEBUGoutput_step = cms.EndPath(process.FEVTDEBUGoutput)
# Schedule definition
process.schedule = cms.Schedule(
