def __init__(self):
self.parResolFix = cms.vint32()
self.parResolOrder = cms.vint32()
self.parResol = cms.vdouble()
self.parResolStep = cms.untracked.vdouble()
self.parResolMin = cms.untracked.vdouble()
self.parResolMax = cms.untracked.vdouble()
def makePuppies( process ):
process.load('CommonTools.PileupAlgos.Puppi_cff')
process.pfNoLepPUPPI = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32( 1,2,22,111,130,310,2112,211,-211,321,-321,999211,2212,-2212 )
)
process.pfLeptonsPUPPET = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32(-11,11,-13,13),
)
process.puppiNoLep = process.puppi.clone()
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))
## puppi met
process.puppiForMET = cms.EDProducer("PuppiPhoton",
candName = cms.InputTag('packedPFCandidates'),
puppiCandName = cms.InputTag('puppi'),
photonName = cms.InputTag('slimmedPhotons'),
photonId = cms.InputTag("egmPhotonIDs:cutBasedPhotonID_PHYS14_PU20bx25_V2p1-standalone-loose"),
pt = cms.double(10),
useRefs = cms.bool(True),
dRMatch = cms.vdouble(10,10,10,10),
pdgids = cms.vint32 (22,11,211,130),
weight = cms.double(1.),
useValueMap = cms.bool(False),
weightsName = cms.InputTag('puppi'),
)
process.puppiForMET.puppiCandName = 'puppiMerged'
def customizeDiphotonCorrections(self,process,processType):
if self.applyDiphotonCorrections:
from flashgg.Systematics.SystematicsCustomize import useEGMTools
useEGMTools(process)
from copy import deepcopy as copy
if processType == "data":
from flashgg.Systematics.SystematicsCustomize import customizePhotonSystematicsForData
customizePhotonSystematicsForData(process)
else:
from flashgg.Systematics.SystematicsCustomize import customizePhotonSystematicsForMC
customizePhotonSystematicsForMC(process)
default1sig = cms.vint32()
default2sig = cms.PSet( firstVar = cms.vint32(), secondVar = cms.vint32())
for vpset,dflt in (process.flashggDiPhotonSystematics.SystMethods,default1sig),(process.flashggDiPhotonSystematics.SystMethods2D,default2sig):
for pset in vpset:
if (processType != "signal") or (not pset.Label.value().startswith("MCSmear")):
pset.NSigmas = copy(dflt)
else:
process.flashggDiPhotonSystematics.SystMethods = cms.VPSet()
process.flashggDiPhotonSystematics.SystMethods2D = cms.VPSet()
process.flashggDiPhotonSystematics.SystMethods.extend(self.extraSysModules)
def createJetSystematicsForTag(process,jetInputTag):
num = jetInputTag.productInstanceLabel
newName = 'flashggJetSystematics'+num
setattr(process,newName,
cms.EDProducer('FlashggJetSystematicProducer',
src = jetInputTag,
SystMethods2D = cms.VPSet(),
SystMethods = cms.VPSet(cms.PSet( MethodName = cms.string("FlashggJetEnergyCorrector"),
Label = cms.string("JEC"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)<5.0"),
Debug = cms.untracked.bool(False)
),
cms.PSet( MethodName = cms.string("FlashggJetSmearConstant"),
Label = cms.string("JER"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)<5.0"),
BinList = smearBins,
Debug = cms.untracked.bool(False),
)
)
)
)
setattr(process.RandomNumberGeneratorService,newName,cms.PSet(initialSeed = cms.untracked.uint32(int(num))))
# e.g. process.RandomNumberGeneratorService.flashggJetSystematics3 = cms.PSet(initialSeed = cms.untracked.uint32(3))
return (getattr(process,newName),cms.InputTag(newName))
def customise_wo_pairs(process):
process=customise(process)
process.generalTracks.TrackProducers = (cms.InputTag('initialStepTracks'),
cms.InputTag('highPtTripletStepTracks'),
cms.InputTag('lowPtTripletStepTracks'),
cms.InputTag('mixedTripletStepTracks'))
process.generalTracks.hasSelector=cms.vint32(1,1,1,1)
process.generalTracks.selectedTrackQuals = cms.VInputTag(cms.InputTag("initialStepSelector","initialStep"),
cms.InputTag("highPtTripletStepSelector","highPtTripletStep"),
cms.InputTag("lowPtTripletStepSelector","lowPtTripletStep"),
cms.InputTag("mixedTripletStep")
)
process.generalTracks.setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1,2,3), pQual=cms.bool(True) )
)
process.newCombinedSeeds.seedCollections = cms.VInputTag(
cms.InputTag('initialStepSeeds'),
cms.InputTag('highPtTripletStepSeeds'),
cms.InputTag('lowPtTripletStepSeeds')
)
process.mixedTripletStepClusters.oldClusterRemovalInfo = cms.InputTag("lowPtTripletStepClusters")
process.mixedTripletStepClusters.trajectories = cms.InputTag("lowPtTripletStepTracks")
process.mixedTripletStepClusters.overrideTrkQuals = cms.InputTag('lowPtTripletStepSelector','lowPtTripletStep')
process.iterTracking.remove(process.PixelPairStep)
return (process)
def makePuppies( process ):
task = getPatAlgosToolsTask(process)
process.load('CommonTools.PileupAlgos.Puppi_cff')
task.add(process.puppi)
process.pfNoLepPUPPI = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32( 1,2,22,111,130,310,2112,211,-211,321,-321,999211,2212,-2212 )
)
task.add(process.pfNoLepPUPPI)
process.pfLeptonsPUPPET = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32(-11,11,-13,13),
)
task.add(process.pfLeptonsPUPPET)
addToProcessAndTask('puppiNoLep', process.puppi.clone(), process, task)
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))
task.add(process.puppiMerged)
process.load('CommonTools.PileupAlgos.PhotonPuppi_cff')
task.add(process.puppiPhoton)
addToProcessAndTask('puppiForMET', process.puppiPhoton.clone(), process, task)
#Line below replaces reference linking wiht delta R matching because the puppi references after merging are not consistent with those of the original PF collection
process.puppiForMET.useRefs = False
#Line below points puppi MET to puppi no lepton which increases the response
process.puppiForMET.puppiCandName = 'puppiMerged'
def __init__(self):
self.parFix = cms.vint32()
self.parOrder = cms.vint32()
self.par = cms.vdouble()
self.parStep = cms.untracked.vdouble()
self.parMin = cms.untracked.vdouble()
self.parMax = cms.untracked.vdouble()
def createJetSystematicsForTag(process,jetInputTag):
num = jetInputTag.productInstanceLabel
newName = 'flashggJetSystematics'+num
setattr(process,newName,
cms.EDProducer('FlashggJetSystematicProducer',
src = jetInputTag,
SystMethods2D = cms.VPSet(),
SystMethods = cms.VPSet(cms.PSet( MethodName = cms.string("FlashggJetEnergyCorrector"),
Label = cms.string("JEC"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)<5.0"),
Debug = cms.untracked.bool(False),
ApplyCentralValue = cms.bool(True),
SetupUncertainties = cms.bool(True),
JetCorrectorTag = cms.InputTag("ak4PFCHSL1FastL2L3Corrector")
),
cms.PSet( MethodName = cms.string("FlashggJetSmear"),
Label = cms.string("JER"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)<5.0"),
RandomLabel = cms.string("rnd_g_JER"), # for no-match case
rho = cms.InputTag('fixedGridRhoAll'),
Debug = cms.untracked.bool(False),
ApplyCentralValue = cms.bool(True),
UseTextFiles = cms.bool(True),
TextFileResolution = cms.string("%s/src/flashgg/Systematics/data/JER/Spring16_25nsV6_MC_PtResolution_AK4PFchs.txt" % environ['CMSSW_BASE']),
TextFileSF = cms.string("%s/src/flashgg/Systematics/data/JER/Spring16_25nsV6_MC_SF_AK4PFchs.txt" % environ['CMSSW_BASE'])
),
cms.PSet( MethodName = cms.string("FlashggJetBTagWeight"),
Label = cms.string("JetBTagWeight"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("pt>25.0&&abs(eta)<2.4"),
BinList = bTagEffBins,
bTag = cms.string(flashggBTag),
bDiscriminator = bDiscriminator76X, #Medium working point for CSV B tagger, for CMSSW74X use: bDiscriminator74X
Debug = cms.untracked.bool(False),
ApplyCentralValue = cms.bool(True)
),
cms.PSet( MethodName = cms.string("FlashggJetRMSShift"),
Label = cms.string("RMSShift"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)>2.5&&abs(eta)<4.7&&pt>20."),
BinList = RMSShiftBins,
ApplyCentralValue = cms.bool(False),
Debug = cms.untracked.bool(False)
),
cms.PSet( MethodName = cms.string("FlashggJetWeight"),
Label = cms.string("UnmatchedPUWeight"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)>2.5&&abs(eta)<4.7&&pt>20.&&pt<50.&&hasGenMatch==0"),
BinList = UnmatchedPUBins,
ApplyCentralValue = cms.bool(False),
Debug = cms.untracked.bool(False),
)
)
)
)
# setattr(process.RandomNumberGeneratorService,newName,cms.PSet(initialSeed = cms.untracked.uint32(int(num))))
# e.g. process.RandomNumberGeneratorService.flashggJetSystematics3 = cms.PSet(initialSeed = cms.untracked.uint32(3))
return (getattr(process,newName),cms.InputTag(newName))
def customizeVPSetForData(systs, phScaleBins):
newvpset = cms.VPSet()
for pset in systs:
if (pset.Label.value().count("Scale") or pset.Label.value().count("SigmaEOverESmearing")) and not pset.Label.value().count("Gain"):
pset.ApplyCentralValue = cms.bool(True) # Turn on central shift for data (it is off for MC)
if type(pset.NSigmas) == type(cms.vint32()):
pset.NSigmas = cms.vint32() # Do not perform shift
else:
pset.NSigmas = cms.PSet( firstVar = cms.vint32(), secondVar = cms.vint32() ) # Do not perform shift - 2D case
if pset.Label.value().count("Scale") and phScaleBins != None:
pset.BinList = phScaleBins
newvpset += [pset]
return newvpset
def load_pfPUPPI_sequence(proc, seq_name, algo, src_puppi='particleFlow', src_vtx='offlinePrimaryVertices', cone_puppi_central=0.3):
setattr(proc, 'pfAllHadronsAndPhotonsFor'+algo,
pfAllNeutralHadrons.clone( src = cms.InputTag('particleFlow'),
pdgId = cms.vint32(22,111,130,310,2112,211,-211,321,-321,999211,2212,-2212)
)
)
setattr(proc, 'particleFlow'+algo,
puppi.clone(
candName = src_puppi,
vertexName = src_vtx
)
)
# configure parameter PuppiCentral.cone
getattr(proc, 'particleFlow'+algo).algos[0].puppiAlgos[0].cone = cone_puppi_central
setattr(proc, 'pf'+algo+'ChargedHadrons', pfAllChargedHadrons.clone(src = cms.InputTag('particleFlow'+algo)))
setattr(proc, 'pf'+algo+'NeutralHadrons', pfAllNeutralHadrons.clone(src = cms.InputTag('particleFlow'+algo)))
setattr(proc, 'pf'+algo+'Photons', pfAllPhotons.clone(src = cms.InputTag('particleFlow'+algo)))
pf_puppi_seq = cms.Sequence(
getattr(proc, 'pfAllHadronsAndPhotonsFor'+algo)
* getattr(proc, 'particleFlow'+algo)
* getattr(proc, 'pf'+algo+'ChargedHadrons')
* getattr(proc, 'pf'+algo+'NeutralHadrons')
* getattr(proc, 'pf'+algo+'Photons')
)
setattr(proc, seq_name, pf_puppi_seq)
def makePuppiesFromMiniAOD( process ):
process.load('CommonTools.PileupAlgos.Puppi_cff')
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
# kind of ugly, is there a better way to do this?
process.pfNoLepPUPPI = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 && abs(pdgId) != 15"))
process.pfLeptonsPUPPET = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) == 13 || abs(pdgId) == 11 || abs(pdgId) == 15"))
process.puppiNoLep = process.puppi.clone()
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))
## puppi met
process.puppiForMET = cms.EDProducer("PuppiPhoton",
candName = cms.InputTag('packedPFCandidates'),
puppiCandName = cms.InputTag('puppi'),
photonName = cms.InputTag('slimmedPhotons'),
photonId = cms.InputTag("egmPhotonIDs:cutBasedPhotonID_PHYS14_PU20bx25_V2p1-standalone-loose"),
pt = cms.double(10),
useRefs = cms.bool(True),
dRMatch = cms.vdouble(10,10,10,10),
pdgids = cms.vint32 (22,11,211,130),
weight = cms.double(1.),
useValueMap = cms.bool(False),
weightsName = cms.InputTag('puppi'),
)
process.puppiForMET.puppiCandName = 'puppiMerged'
def customizeSystematicsForBackground(process):
# Keep default MC central value behavior, remove all up/down shifts
customizeSystematicsForMC(process)
from flashgg.Taggers.flashggTags_cff import UnpackedJetCollectionVInputTag
vpsetlist = [process.flashggDiPhotonSystematics.SystMethods, process.flashggMuonSystematics.SystMethods, process.flashggElectronSystematics.SystMethods]
vpsetlist += [getattr(process,"flashggJetSystematics%i"%i).SystMethods for i in range(len(UnpackedJetCollectionVInputTag))]
vpsetlist += [process.flashggDiPhotonSystematics.SystMethods2D, process.flashggMuonSystematics.SystMethods2D, process.flashggElectronSystematics.SystMethods2D]
vpsetlist += [getattr(process,"flashggJetSystematics%i"%i).SystMethods2D for i in range(len(UnpackedJetCollectionVInputTag))]
for vpset in vpsetlist:
for pset in vpset:
if type(pset.NSigmas) == type(cms.vint32()):
pset.NSigmas = cms.vint32() # Do not perform shift
else:
pset.NSigmas = cms.PSet( firstVar = cms.vint32(), secondVar = cms.vint32() ) # Do not perform shift - 2D case
if hasattr(pset,"SetupUncertainties"):
pset.SetupUncertainties = False
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(process):
print "Add "
print "process.local = cms.PSet() # for local running "
if hasattr(process, "local"):
print "#########################################################"
print " local run!"
print "#########################################################"
print
print
print
base = "file:/scratch/scratch0/tfruboes/DATA_tmp/RelValMinBias/CMSSW_4_2_0_pre4-MC_42_V1-v1/GEN-SIM-DIGI-RAW-HLTDEBUG/"
process.mix.input.fileNames = cms.untracked.vstring(
base + "4C824492-2639-E011-9506-001A928116F0.root",
base + "9ED6309B-C238-E011-A1D6-003048678ADA.root",
base + "487A3591-CA38-E011-92A8-00248C0BE013.root",
base + "0E5A4D31-BD38-E011-93B7-0026189437F2.root",
)
process.mix.input.nbPileupEvents.probFunctionVariable = cms.vint32()
process.mix.input.nbPileupEvents.probValue = cms.vdouble()
# print dir(process.mix.input.nbPileupEvents.probValue)
for i in range(0, 51):
process.mix.input.nbPileupEvents.probFunctionVariable.append(i)
val = 0.25
if i == 0 or i == 9 or i == 19 or i == 29:
# val=1
# if i==0:
process.mix.input.nbPileupEvents.probValue.append(val)
else:
process.mix.input.nbPileupEvents.probValue.append(0.0)
return process
def customise_Reco(process):
#lowering HO threshold with SiPM
for prod in process.particleFlowRecHitHO.producers:
prod.qualityTests = cms.VPSet(
cms.PSet(
name = cms.string("PFRecHitQTestThreshold"),
threshold = cms.double(0.05) # new threshold for SiPM HO
),
cms.PSet(
name = cms.string("PFRecHitQTestHCALChannel"),
maxSeverities = cms.vint32(11),
cleaningThresholds = cms.vdouble(0.0),
flags = cms.vstring('Standard')
)
)
#Lower Thresholds also for Clusters!!!
for p in process.particleFlowClusterHO.seedFinder.thresholdsByDetector:
p.seedingThreshold = cms.double(0.08)
for p in process.particleFlowClusterHO.initialClusteringStep.thresholdsByDetector:
p.gatheringThreshold = cms.double(0.05)
for p in process.particleFlowClusterHO.pfClusterBuilder.recHitEnergyNorms:
p.recHitEnergyNorm = cms.double(0.05)
process.particleFlowClusterHO.pfClusterBuilder.positionCalc.logWeightDenominator = cms.double(0.05)
process.particleFlowClusterHO.pfClusterBuilder.allCellsPositionCalc.logWeightDenominator = cms.double(0.05)
return process
def customise_Digi(process):
if hasattr(process,'mix'):
process.mix.digitizers.hcal.HBHEUpgradeQIE = True
process.mix.digitizers.hcal.hb.siPMCells = cms.vint32([1])
process.mix.digitizers.hcal.hb.photoelectronsToAnalog = cms.vdouble([10.]*16)
process.mix.digitizers.hcal.hb.pixels = cms.int32(4500*4*2)
process.mix.digitizers.hcal.he.photoelectronsToAnalog = cms.vdouble([10.]*16)
process.mix.digitizers.hcal.he.pixels = cms.int32(4500*4*2)
process.mix.digitizers.hcal.HFUpgradeQIE = True
process.mix.digitizers.hcal.HcalReLabel.RelabelHits=cms.untracked.bool(True)
if hasattr(process,'HcalTPGCoderULUT'):
process.HcalTPGCoderULUT.hcalTopologyConstants.mode=cms.string('HcalTopologyMode::SLHC')
process.HcalTPGCoderULUT.hcalTopologyConstants.maxDepthHB=cms.int32(3)
process.HcalTPGCoderULUT.hcalTopologyConstants.maxDepthHE=cms.int32(5)
if hasattr(process,'simHcalDigis'):
process.simHcalDigis.useConfigZSvalues=cms.int32(1)
process.simHcalDigis.HBlevel=cms.int32(16)
process.simHcalDigis.HElevel=cms.int32(16)
process.simHcalDigis.HOlevel=cms.int32(16)
process.simHcalDigis.HFlevel=cms.int32(16)
process.digitisation_step.remove(process.simHcalTriggerPrimitiveDigis)
process.digitisation_step.remove(process.simHcalTTPDigis)
return process
def runPFNoPileUp(process):
process.load("CommonTools.ParticleFlow.pfParticleSelection_cff")
process.pfPileUpCandidates = cms.EDProducer(
"TPPFCandidatesOnPFCandidates",
enable = cms.bool( True ),
verbose = cms.untracked.bool( False ),
name = cms.untracked.string("pileUpCandidates"),
topCollection = cms.InputTag("pfNoPileUpIso"),
bottomCollection = cms.InputTag("particleFlow"),
)
#enable PF no Pile Up
process.pfPileUp.Enable = cms.bool(True)
#Apply the bug fix in 42X
process.pfPileUp.checkClosestZVertex = cms.bool(True)
#Put all charged particles in charged hadron collection(electrons and muons)
process.pfAllChargedHadrons.pdgId = cms.vint32(211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
process.pileUpHadrons = cms.EDFilter("PdgIdPFCandidateSelector",
src = cms.InputTag("pfPileUpCandidates"),
pdgId = cms.vint32(211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
)
process.pfAllElectrons.src = cms.InputTag("pfNoPileUpIso")
process.pfAllMuons = cms.EDFilter("PdgIdPFCandidateSelector",
src = cms.InputTag("pfNoPileUpIso"),
pdgId = cms.vint32(13,-13)
)
process.pfPostSequence = cms.Sequence(
process.pfParticleSelectionSequence+
process.pfAllMuons+
process.pfPileUpCandidates+
process.pileUpHadrons
)
process.patPreIsoSeq = process.pfPostSequence
process.patDefaultSequence = cms.Sequence(process.patPreIsoSeq*process.patDefaultSequence)
def submitTest(script,
mode,
masses,
useME, useJac, useMET, useTF, usePDF,
shiftMomenta,testMassScan,testPermutations,
scaleH,scaleL,scaleMET,
evLow,evHigh):
print "Overload testME.py..."
os.system('cp ../python/testME.py ./')
from testME import process
print "Creating the shell file for the batch..."
scriptName = 'job_'+script+'.sh'
jobName = 'job_'+script
process.fwliteInput.outFileName = cms.string('./root/TestMENew_'+script+'.root')
process.fwliteInput.mode = cms.untracked.int32(mode)
process.fwliteInput.masses = masses
process.fwliteInput.useME = cms.int32(useME)
process.fwliteInput.useJac = cms.int32(useJac)
process.fwliteInput.useMET = cms.int32(useMET)
process.fwliteInput.useTF = cms.int32(useTF)
process.fwliteInput.usePDF = cms.int32(usePDF)
process.fwliteInput.shiftMomenta = cms.int32(shiftMomenta)
process.fwliteInput.testMassScan = cms.int32(testMassScan)
process.fwliteInput.testPermutations = cms.int32(testPermutations)
process.fwliteInput.scaleH = cms.double(scaleH)
process.fwliteInput.scaleL = cms.double(scaleL)
process.fwliteInput.scaleMET = cms.double(scaleMET)
process.fwliteInput.evLimits = cms.vint32(evLow,evHigh)
out = open(jobName+'.py','w')
out.write(process.dumpPython())
f = open(scriptName,'w')
f.write('#!/bin/bash\n\n')
f.write('cd /shome/bianchi/CMSSW_5_3_3_patch2/src/Bianchi/TTHStudies/bin/\n')
f.write('source /swshare/psit3/etc/profile.d/cms_ui_env.sh\n')
f.write('export SCRAM_ARCH="slc5_amd64_gcc462"\n')
f.write('source $VO_CMS_SW_DIR/cmsset_default.sh\n')
f.write('eval `scramv1 runtime -sh`\n')
f.write('export LD_PRELOAD="libglobus_gssapi_gsi_gcc64pthr.so.0":${LD_PRELOAD}\n')
f.write('\n\n')
f.write('\n\n')
f.write('TestMENew ./'+jobName+'.py\n')
f.close()
os.system('chmod +x '+scriptName)
submitToQueue = 'qsub -V -cwd -l h_vmem=6G -q all.q -N '+jobName+' '+scriptName
print submitToQueue
os.system(submitToQueue)
print "\n@@@@@ END JOB @@@@@@@@@@@@@@@"
def createJetSystematicsForTag(process,jetInputTag):
num = jetInputTag.productInstanceLabel
newName = 'flashggJetSystematics'+num
setattr(process,newName,
cms.EDProducer('FlashggJetSystematicProducer',
src = jetInputTag,
SystMethods2D = cms.VPSet(),
SystMethods = cms.VPSet(cms.PSet( MethodName = cms.string("FlashggJetEnergyCorrector"),
Label = cms.string("JEC"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)<5.0"),
Debug = cms.untracked.bool(False),
ApplyCentralValue = cms.bool(True),
SetupUncertainties = cms.bool(True),
JetCorrectorTag = cms.InputTag("ak4PFCHSL1FastL2L3Corrector")
),
cms.PSet( MethodName = cms.string("FlashggJetSmear"),
Label = cms.string("JER"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)<5.0"),
RandomLabel = cms.string("rnd_g_JER"), # for no-match case
rho = cms.InputTag('fixedGridRhoAll'),
Debug = cms.untracked.bool(False),
ApplyCentralValue = cms.bool(True)
),
cms.PSet( MethodName = cms.string("FlashggJetBTagWeight"),
Label = cms.string("JetBTagWeight"),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("pt>25.0&&abs(eta)<2.4"),
BinList = bTagEffBins,
bTag = cms.string(flashggBTag),
bDiscriminator = bDiscriminator76X, #Medium working point for CSV B tagger, for CMSSW74X use: bDiscriminator74X
Debug = cms.untracked.bool(False),
ApplyCentralValue = cms.bool(True)
)
)
)
)
# setattr(process.RandomNumberGeneratorService,newName,cms.PSet(initialSeed = cms.untracked.uint32(int(num))))
# e.g. process.RandomNumberGeneratorService.flashggJetSystematics3 = cms.PSet(initialSeed = cms.untracked.uint32(3))
return (getattr(process,newName),cms.InputTag(newName))
def set_gun(process, pid, pt, anti=True, etas=[-2.5,2.5], phis=[-3.14159265359,3.14159265359]):
process.generator = cms.EDProducer('FlatRandomPtGunProducer', AddAntiParticle = cms.bool(anti))
process.generator.PGunParameters = cms.PSet(
MinPt = cms.double(pt - 1e-3),
MaxPt = cms.double(pt + 1e-3),
PartID = cms.vint32(pid),
MinEta = cms.double(etas[0]),
MaxEta = cms.double(etas[1]),
MinPhi = cms.double(phis[0]),
MaxPhi = cms.double(phis[1]),
)
def customisePU(process):
process.mix.input.nbPileupEvents.probFunctionVariable=cms.vint32(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24)
process.mix.input.nbPileupEvents.probValue=cms.vdouble(
0.000374363,0.00019119,0.00130157,0.0238392,0.0828361,
0.118202,0.119698,0.107855,0.0947511,0.0865411,
0.0789534,0.0726418,0.067148,0.0575388,0.0425806,
0.0259079,0.0126324,0.00492452,0.00155633,0.000410135,
9.32796e-05,1.87681e-05,3.41785e-06,5.98753e-07,1.11116e-07)
return(process)
def GetPSet(self , name = None , applyCentralValue = True):
if not name :
name = self.Name
self.SystematicsPSET = cms.PSet( MethodName = cms.string("FlashggMuonWeight"),
Label = cms.string(name),
NSigmas = cms.vint32(-1,1),
OverallRange = cms.string("abs(eta)<2.4"),
BinList = self.binInfo,
Debug = cms.untracked.bool(False),
ApplyCentralValue = cms.bool(applyCentralValue)
)
return self.SystematicsPSET
def customizeDiphotonCorrections(self,process,processType):
if processType == "data":
from flashgg.Systematics.SystematicsCustomize import customizePhotonSystematicsForData
customizePhotonSystematicsForData(process)
else:
from flashgg.Systematics.SystematicsCustomize import customizePhotonSystematicsForMC
customizePhotonSystematicsForMC(process)
for vpset in process.flashggDiPhotonSystematics.SystMethods,process.flashggDiPhotonSystematics.SystMethods2D:
for pset in vpset:
if (processType != "signal") or (not pset.Label.value().startswith("MCSmear")):
pset.NSigmas = cms.vint32()
def addNMinusOnePhoSelections(
self, process, label, selectorTemplate, nMinusOne, dumperTemplate=None, splitByIso=False
):
"""
Add photon producer n-1 selection and corresponding dumper to the process
"""
modules = []
if not dumperTemplate:
dumperTemplate = self.singlePhoDumperTemplate
for settings in nMinusOne:
if len(settings) == 7:
ignore, invert, ilabel, dumpTrees, dumpWorkspace, dumpHistos, doSplitByIso = settings
if hasattr(selectorTemplate, "ignore"):
ignore += selectorTemplate.ignore
nMinus1Template = selectorTemplate.clone(
ignore=cms.vint32(ignore), invert=cms.vint32(invert[0]), invertNtimes=cms.int32(invert[1])
)
else:
ignore, ilabel, dumpTrees, dumpWorkspace, dumpHistos = settings[:5]
if hasattr(selectorTemplate, "ignore"):
ignore += selectorTemplate.ignore
nMinus1Template = selectorTemplate.clone(ignore=cms.vint32(ignore))
if len(settings) == 0:
doSplitByIso = settings[5]
else:
doSplitByIso = splitByIso
modules += self.addPhoSelection(
process,
"%s%s" % (label, ilabel),
nMinus1Template,
dumpTrees=dumpTrees,
dumpWorkspace=dumpWorkspace,
dumpHistos=dumpHistos,
splitByIso=doSplitByIso,
dumperTemplate=dumperTemplate,
)
return modules
def customizeForOILooseFilter(process): process.hltIterL3OIMuonTrackCutClassifier = cms.EDProducer( "TrackCutClassifier", src = cms.InputTag( "hltIterL3OIMuCtfWithMaterialTracks" ), GBRForestLabel = cms.string( "" ), beamspot = cms.InputTag( "hltOnlineBeamSpot" ), vertices = cms.InputTag( "Notused" ), qualityCuts = cms.vdouble( -0.7, 0.1, 0.4 ), mva = cms.PSet( minPixelHits = cms.vint32( 0, 0, 1 ), maxDzWrtBS = cms.vdouble( 3.40282346639E38, 24.0, 100.0 ), dr_par = cms.PSet( d0err = cms.vdouble( 0.003, 0.003, 3.40282346639E38 ), dr_par2 = cms.vdouble( 0.3, 0.3, 3.40282346639E38 ), dr_par1 = cms.vdouble( 0.4, 0.4, 3.40282346639E38 ), dr_exp = cms.vint32( 4, 4, 2147483647 ), d0err_par = cms.vdouble( 0.001, 0.001, 3.40282346639E38 ) ), maxLostLayers = cms.vint32( 4, 3, 4 ), min3DLayers = cms.vint32( 1, 2, 1 ), dz_par = cms.PSet( dz_par1 = cms.vdouble( 0.4, 0.4, 3.40282346639E38 ), dz_par2 = cms.vdouble( 0.35, 0.35, 3.40282346639E38 ), dz_exp = cms.vint32( 4, 4, 2147483647 ) ), minNVtxTrk = cms.int32( 2 ), maxDz = cms.vdouble( 0.5, 0.2, 3.40282346639E38 ), minNdof = cms.vdouble( 1.0E-5, 1.0E-5, 1.0E-5 ), maxChi2 = cms.vdouble( 3.40282346639E38, 3.40282346639E38, 3.40282346639E38 ), maxChi2n = cms.vdouble( 10.0, 1.0, 1.0 ), maxDr = cms.vdouble( 0.5, 0.03, 3.40282346639E38 ), minLayers = cms.vint32( 3, 5, 3 ) ), ignoreVertices = cms.bool( True ), GBRForestFileName = cms.string( "" ) )
def customizeSignal(self,process):
process.flashggGenPhotonsExtra.defaultType = 1
from flashgg.MicroAOD.flashggMet_RunCorrectionAndUncertainties_cff import runMETs,setMetCorr
runMETs(process,True) #isMC
from flashgg.MicroAOD.METcorr_multPhiCorr_80X_sumPt_cfi import multPhiCorr_MC_DY_80X
if not (os.environ["CMSSW_VERSION"].count("CMSSW_9_2") or os.environ["CMSSW_VERSION"].count("CMSSW_9_4")):
setMetCorr(process,multPhiCorr_MC_DY_80X)
process.p *=process.flashggMetSequence
if os.environ["CMSSW_VERSION"].count("CMSSW_8_0"):
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
process.rivetProducerHTXS = cms.EDProducer('HTXSRivetProducer',
HepMCCollection = cms.InputTag('myGenerator','unsmeared'),
ProductionMode = cms.string('PRODUCTIONMODENOTSET'),
)
process.mergedGenParticles = cms.EDProducer("MergedGenParticleProducer",
inputPruned = cms.InputTag("prunedGenParticles"),
inputPacked = cms.InputTag("packedGenParticles"),
)
process.myGenerator = cms.EDProducer("GenParticles2HepMCConverterHTXS",
genParticles = cms.InputTag("mergedGenParticles"),
genEventInfo = cms.InputTag("generator"),
)
process.p *= process.mergedGenParticles
process.p *= process.myGenerator
process.p *= process.rivetProducerHTXS
process.out.outputCommands.append("keep *_rivetProducerHTXS_*_*")
if os.environ["CMSSW_VERSION"].count("CMSSW_9_4"):
#raise Exception,"Debugging ongoing for HTXS in CMSSW 9"
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")
process.rivetProducerHTXS = cms.EDProducer('HTXSRivetProducer',
HepMCCollection = cms.InputTag('myGenerator','unsmeared'),
LHERunInfo = cms.InputTag('externalLHEProducer'),
ProductionMode = cms.string('AUTO'),
)
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), ## for the Higgs analysis
)
process.p *= process.mergedGenParticles
process.p *= process.myGenerator
process.p *= process.rivetProducerHTXS
process.out.outputCommands.append('keep *_*_*_runRivetAnalysis')
self.customizePDFs(process)
def makePuppies( process ):
process.load('CommonTools.PileupAlgos.Puppi_cff')
process.pfNoLepPUPPI = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32( 1,2,22,111,130,310,2112,211,-211,321,-321,999211,2212,-2212 )
)
process.pfLeptonsPUPPET = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32(-11,11,-13,13),
)
process.puppiNoLep = process.puppi.clone()
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))
process.load('CommonTools.PileupAlgos.PhotonPuppi_cff')
process.puppiForMET = process.puppiPhoton.clone()
#Line below replaces reference linking wiht delta R matching this is because the reference key in packed candidates differs to PF candidates (must be done when reading Reco)
process.puppiForMET.useRefs = False
#Line below points puppi MET to puppi no lepton which increases the response
process.puppiForMET.puppiCandName = 'puppiMerged'
def quadrereco(process):
process.load("FWCore.MessageService.MessageLogger_cfi")
process.load('Configuration.StandardSequences.Services_cff')
process.load('Configuration.StandardSequences.DigiToRaw_cff')
process.load('Configuration.StandardSequences.RawToDigi_cff')
process.load('Configuration.Geometry.GeometryIdeal_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_cff')
process.load('Configuration.StandardSequences.Reconstruction_cff')
process.Dump = cms.EDAnalyzer("EventContentAnalyzer")
#### Include QuadSeed Sequence after SingleLeg Sequence, before the track merger:::
process.ConvStep.insert(5,process.Conv2Step)
#### Merge SingleLeg/QuadSeed tracks:::
process.conversionStepTracks.TrackProducers = cms.VInputTag(cms.InputTag('convStepTracks'),cms.InputTag('conv2StepTracks'))
process.conversionStepTracks.hasSelector=cms.vint32(1,1)
process.conversionStepTracks.selectedTrackQuals = cms.VInputTag(cms.InputTag("convStepSelector","convStep"),cms.InputTag("conv2StepSelector","conv2Step"))
process.conversionStepTracks.setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1), pQual=cms.bool(True) ))
process.quadrereco = cms.Sequence(
#localReco
process.siPixelRecHits*
process.siStripMatchedRecHits*
#process.ecalLocalRecoSequence*
#globalReco
process.offlineBeamSpot*
process.recopixelvertexing*
process.trackingGlobalReco*
process.caloTowersRec*
process.vertexreco*
process.egammaGlobalReco
#process.Dump
)
return process
def configurePFNoPileup(process):
process.load(
"CommonTools.ParticleFlow.ParticleSelectors.pfCandsForIsolation_cff")
process.pfPileUpCandidates = cms.EDProducer(
"TPPFCandidatesOnPFCandidates",
enable = cms.bool( True ),
verbose = cms.untracked.bool( False ),
name = cms.untracked.string("pileUpCandidates"),
topCollection = cms.InputTag("pfNoPileUp"),
bottomCollection = cms.InputTag("particleFlow"),
)
#enable PF no Pile Up
process.pfPileUp.Enable = cms.bool(True)
#Put all charged particles in charged hadron collection(electrons and muons)
process.pfAllChargedHadrons.pdgId = cms.vint32(
211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
assert(process.pfAllChargedHadrons.src.value() == "pfNoPileUp")
process.pileUpHadrons = cms.EDFilter(
"PdgIdPFCandidateSelector",
src = cms.InputTag("pfPileUpCandidates"),
pdgId = cms.vint32(211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
)
process.pfAllElectrons.src = cms.InputTag("pfNoPileUp")
process.pfAllMuons = cms.EDFilter(
"PdgIdPFCandidateSelector",
src = cms.InputTag("pfNoPileUp"),
pdgId = cms.vint32(13,-13)
)
process.pfPostSequence = cms.Sequence(
process.pfCandsForIsolationSequence+
process.pfAllMuons+
process.pfPileUpCandidates+
process.pileUpHadrons
)
return process.pfPostSequence
def addSelectedPFlowParticle(process,verbose=False):
if verbose:
print "[Info] Adding pf-particles (for pf-isolation and pf-seed pat-leptons)"
process.load("CommonTools.ParticleFlow.ParticleSelectors.pfSortByType_cff")
process.load("CommonTools.ParticleFlow.pfNoPileUp_cff")
process.pfAllChargedCandidates = process.pfAllChargedHadrons.clone()
process.pfAllChargedCandidates.pdgId.extend(process.pfAllMuons.pdgId.value())
process.pfAllChargedCandidates.pdgId.extend(process.pfAllElectrons.pdgId.value())
process.pfPU = cms.EDProducer(
"TPPFCandidatesOnPFCandidates",
enable = cms.bool( True ),
verbose = cms.untracked.bool( False ),
name = cms.untracked.string("puPFCandidates"),
topCollection = cms.InputTag("pfNoPileUp"),
bottomCollection = cms.InputTag("particleFlow"),
)
process.pfAllChargedHadronsPU = process.pfAllChargedHadrons.clone(src='pfPU')
#################################################################
process.pfNoCharged = process.pfPU.clone(
name = cms.untracked.string("noChargedPFCandidates"),
topCollection = cms.InputTag("pfAllChargedHadrons"),
bottomCollection = cms.InputTag("particleFlow"),
)
process.pfAllNeutral = cms.EDFilter(
"PdgIdPFCandidateSelector",
pdgId = cms.vint32(111, 130, 310, 2112, 22),
src = cms.InputTag("pfNoCharged")
)
#################################################################
process.pfCandidateSelectionByType = cms.Sequence(
process.pfNoPileUpSequence *
( process.pfAllNeutralHadrons +
process.pfAllChargedHadrons +
process.pfAllChargedCandidates +
process.pfAllPhotons +
(process.pfPU * process.pfAllChargedHadronsPU )
) +
process.pfAllMuons +
process.pfAllElectrons +
( process.pfNoCharged+process.pfAllNeutral)
)
process.pfPileUp.Enable = True
process.pfPileUp.checkClosestZVertex = True
process.pfPileUp.Vertices = "offlinePrimaryVertices"
process.pfAllMuons.src = "pfNoPileUp"
process.pfAllElectrons.src = "pfNoPileUp"
import FWCore.ParameterSet.Config as cms
genMuons = cms.EDFilter("PdgIdAndStatusCandViewSelector",
src = cms.InputTag("genParticles"),
pdgId = cms.vint32( 13 ),
status = cms.vint32(1),
)
goodMuons = cms.EDFilter("CandViewSelector",
src = cms.InputTag("genMuons"),
cut = cms.string("pt > 40 & abs(eta) < 2.4")
)
muSequence = cms.Sequence(genMuons + goodMuons)
# Other statements
process.genstepfilter.triggerConditions=cms.vstring("generation_step")
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2017_design', '')
process.generator = cms.EDProducer("FlatRandomEThetaGunProducer",
AddAntiParticle = cms.bool(True),
PGunParameters = cms.PSet(
MinE = cms.double(99.99),
MaxE = cms.double(100.01),
MinTheta = cms.double(0.0),
MaxTheta = cms.double(0.0),
MinPhi = cms.double(-3.14159265359),
MaxPhi = cms.double(3.14159265359),
PartID = cms.vint32(13)
),
Verbosity = cms.untracked.int32(0),
firstRun = cms.untracked.uint32(1),
psethack = cms.string('single muon E 100')
)
process.VtxSmeared.MeanZ = 10
process.VtxSmeared.SigmaZ = 0
process.HGCalTBAnalyzer.DoRecHits = False
# Path and EndPath definitions
process.generation_step = cms.Path(process.pgen)
process.simulation_step = cms.Path(process.psim)
process.genfiltersummary_step = cms.EndPath(process.genFilterSummary)
process.digitisation_step = cms.Path(process.mix)
process.analysis_step = cms.Path(process.HGCalTBAnalyzer)
SiStripMonitorClusterBPTX.TH1StripNoise3ApvCycle.globalswitchon = True
SiStripMonitorClusterBPTX.ClusterHisto = True
SiStripMonitorClusterBPTX.BPTXfilter = cms.PSet(
andOr=cms.bool(False),
dbLabel=cms.string("SiStripDQMTrigger"),
l1Algorithms=cms.vstring('L1Tech_BPTX_plus_AND_minus.v0', 'L1_ZeroBias'),
andOrL1=cms.bool(True),
errorReplyL1=cms.bool(True),
l1BeforeMask=cms.bool(
True
) # specifies, if the L1 algorithm decision should be read as before (true) or after (false) masking is applied.
)
SiStripMonitorClusterBPTX.PixelDCSfilter = cms.PSet(
andOr=cms.bool(False),
dcsInputTag=cms.InputTag("scalersRawToDigi"),
dcsPartitions=cms.vint32(28, 29),
andOrDcs=cms.bool(False),
errorReplyDcs=cms.bool(True),
)
SiStripMonitorClusterBPTX.StripDCSfilter = cms.PSet(
andOr=cms.bool(False),
dcsInputTag=cms.InputTag("scalersRawToDigi"),
dcsPartitions=cms.vint32(24, 25, 26, 27),
andOrDcs=cms.bool(False),
errorReplyDcs=cms.bool(True),
)
# Clone for SiStripMonitorTrack for all PDs but Minimum Bias and Jet ####
import DQM.SiStripMonitorTrack.SiStripMonitorTrack_cfi
SiStripMonitorTrackCommon = DQM.SiStripMonitorTrack.SiStripMonitorTrack_cfi.SiStripMonitorTrack.clone(
)
EcalMaxDR=cms.double(0.5),
KeepOutsideCone=cms.bool(True)),
HcalHitsCuts=cms.PSet(HBHEEnergyCut=cms.double(0.35),
HFEnergyCut=cms.double(1.0),
HOEnergyCut=cms.double(0.7),
HcalMaxDR=cms.double(0.6),
KeepOutsideCone=cms.bool(True)),
BasicClusterCuts=cms.PSet(EnergyCut=cms.double(-1.0)),
SuperClusterCuts=cms.PSet(EnergyCut=cms.double(-1.0)),
CaloTowerCuts=cms.PSet(EtCut=cms.double(1.0)),
TrackCuts=cms.PSet(PtCut=cms.double(-1.0)),
TPCuts=cms.PSet(tpLvpCut=cms.double(99999.0),
tpEtaCut=cms.double(2.5),
tpTvpCut=cms.double(99999.0),
tpPtCut=cms.double(1.0),
tpPdgidCut=cms.vint32(11, 22)),
IsoCuts=cms.PSet(InnerCone=cms.double(0.015), OuterCone=cms.double(0.3)),
ElectronCuts=cms.PSet(EtCut=cms.double(0.0)),
MuonCuts=cms.PSet(PtCut=cms.double(-1.0)),
PhotonCuts=cms.PSet(EtCut=cms.double(0.0)),
ConvertedPhotonCuts=cms.PSet(EtCut=cms.double(0.0)),
JetCuts=cms.PSet(EnergyCut=cms.double(0.0)),
# DEBUG
Debug_Level=cms.int32(0),
# SELECTORS
SelectorNumber=cms.int32(0),
SelectorCuts0=cms.PSet(RecoPhotonNumber=cms.int32(1000),
RecoMuonNumber=cms.int32(1000),
RecoElectronNumber=cms.int32(1000),
# processParameters = cms.vstring('MSEL = 0 ! User defined processes',
# 'MSUB(81) = 1 ! qqbar to QQbar',
# 'MSUB(82) = 1 ! gg to QQbar',
# 'MSTP(7) = 6 ! flavour = top',
# 'PMAS(6,1) = 175. ! top quark mass'),
# # This is a vector of ParameterSet names to be read, in this order
# parameterSets = cms.vstring('pythiaUESettings',
# 'processParameters')
# )
#)
################
process.generator = cms.EDProducer("FlatRandomPtGunProducer",
PGunParameters = cms.PSet(
MaxPt = cms.double(200.0),
MinPt = cms.double(0.9),
PartID = cms.vint32(-13, -13),
MaxEta = cms.double(2.5),
MaxPhi = cms.double(3.14159265359),
MinEta = cms.double(-2.5),
MinPhi = cms.double(-3.14159265359)
),
Verbosity = cms.untracked.int32(0),
psethack = cms.string('Four mu pt 1 to 200'),
AddAntiParticle = cms.bool(True),
firstRun = cms.untracked.uint32(1)
)
##########################################################
process.load("Validation.RecoTrack.cutsTPEffic_cfi")
process.load("Validation.RecoTrack.cutsTPFake_cfi")
def loadPF2PAT(process, mcInfo, jetMetCorrections, extMatch,
doSusyTopProjection, doType1MetCorrection, doType0MetCorrection,
postfix):
#-- PAT standard config -------------------------------------------------------
process.load("PhysicsTools.PatAlgos.patSequences_cff")
#-- Jet corrections -----------------------------------------------------------
process.patJetCorrFactors.levels = jetMetCorrections
#-- PF2PAT config -------------------------------------------------------------
from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT
usePF2PAT(process,
runPF2PAT=True,
jetAlgo='AK5',
runOnMC=(mcInfo == 1),
postfix=postfix,
jetCorrections=('AK5PFchs', jetMetCorrections),
typeIMetCorrections=doType1MetCorrection)
if doType0MetCorrection:
getattr(process, 'patType1CorrectedPFMet' +
postfix).srcType1Corrections = cms.VInputTag(
cms.InputTag("patPFJetMETtype1p2Corr" + postfix, "type1"),
cms.InputTag("patPFMETtype0Corr" + postfix))
#process.patJetsPF.embedGenJetMatch = False
#process.patJetsPF.embedPFCandidates = False
#drop tracks
process.patElectronsPF.embedTrack = True
process.patMuonsPF.embedTrack = True
process.electronMatchPF.maxDeltaR = cms.double(0.2)
process.electronMatchPF.maxDPtRel = cms.double(999999.)
process.electronMatchPF.checkCharge = False
process.muonMatchPF.maxDeltaR = cms.double(0.2)
process.muonMatchPF.maxDPtRel = cms.double(999999.)
process.muonMatchPF.checkCharge = False
if extMatch:
process.electronMatchPF.mcStatus = cms.vint32(1, 5)
process.electronMatchPF.matched = "mergedTruth"
process.muonMatchPF.mcStatus = cms.vint32(1, 5)
process.muonMatchPF.matched = "mergedTruth"
process.genParticlesForJets.src = "mergedTruth"
process.genParticlesForJetsNoMuNoNu.src = "mergedTruth"
process.genParticlesForJetsNoNu.src = "mergedTruth"
process.patJetPartonMatchPF.matched = "mergedTruth"
process.patJetPartonsPF.src = "mergedTruth"
process.photonMatchPF.matched = "mergedTruth"
#process.tauGenJetsPF.GenParticles = "mergedTruth"
#process.tauMatchPF.matched = "mergedTruth"
#Remove jet pt cut
#process.pfJetsPF.ptMin = 0.
#include tau decay mode in pat::Taus (elese it will just be uninitialized)
#process.patTausPF.addDecayMode = True
#process.patTausPF.decayModeSrc = "shrinkingConePFTauDecayModeProducerPF"
#Set isolation cone to 0.3 for PF leptons
# TODO: fix this for electrons and muons
#process.pfElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId"))
#process.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId")
#process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
#process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId"))
#process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId")
#process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
#process.pfElectronsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFIdPF"))
#process.pfElectronsPF.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFIdPF")
#process.pfElectronsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFIdPF"), cms.InputTag("elPFIsoValueGamma03PFIdPF"))
#process.pfIsolatedElectronsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFIdPF"))
#process.pfIsolatedElectronsPF.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFIdPF")
#process.pfIsolatedElectronsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFIdPF"), cms.InputTag("elPFIsoValueGamma03PFIdPF"))
#process.pfMuons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03"))
#process.pfMuons.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03")
#process.pfMuons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03"), cms.InputTag("muPFIsoValueGamma03"))
#process.pfIsolatedMuons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03"))
#process.pfIsolatedMuons.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03")
#process.pfIsolatedMuons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03"), cms.InputTag("muPFIsoValueGamma03"))
#process.pfMuonsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03PF"))
#process.pfMuonsPF.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03PF")
#process.pfMuonsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03PF"), cms.InputTag("muPFIsoValueGamma03PF"))
#process.pfIsolatedMuonsPF.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("muPFIsoValueCharged03mu03PF"))
#process.pfIsolatedMuonsPF.deltaBetaIsolationValueMap = cms.InputTag("muPFIsoValuePU03PF")
#process.pfIsolatedMuonsPF.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("muPFIsoValueNeutral03PF"), cms.InputTag("muPFIsoValueGamma03PF"))
#-- Enable pileup sequence -------------------------------------------------------------
#Vertices
process.goodVertices = cms.EDFilter(
"VertexSelector",
src=cms.InputTag("offlinePrimaryVertices"),
cut=cms.string(
"!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
filter=cms.bool(False),
)
process.pfPileUpPF.Vertices = "goodVertices"
process.pfPileUpPF.Enable = True
process.pfNoPileUpSequencePF.replace(
process.pfPileUpPF, process.goodVertices + process.pfPileUpPF)
if not doSusyTopProjection:
return
#-- Top projection selection -----------------------------------------------------------
#Electrons
#relax all selectors *before* pat-lepton creation
process.pfElectronsFromVertexPF.dzCut = 9999.0
process.pfElectronsFromVertexPF.d0Cut = 9999.0
process.pfSelectedElectronsPF.cut = ""
process.pfRelaxedElectronsPF = process.pfIsolatedElectronsPF.clone(
isolationCut=3.)
process.pfIsolatedElectronsPF.isolationCut = 0.15
process.pfElectronsFromGoodVertex = cms.EDFilter(
"IPCutPFCandidateSelector",
src=cms.InputTag("pfIsolatedElectronsPF"), # PFCandidate source
vertices=cms.InputTag("goodVertices"), # vertices source
d0Cut=cms.double(0.04), # transverse IP
dzCut=cms.double(1.), # longitudinal IP
d0SigCut=cms.double(99.), # transverse IP significance
dzSigCut=cms.double(99.), # longitudinal IP significance
)
electronSelection = "abs( eta ) < 2.5 & pt > 5"
electronSelection += " & mva_e_pi > 0.4" # same as patElectron::mva()
#electronSelection += " & (isEB & (sigmaIetaIeta < 0.024 & hadronicOverEm < 0.15) | isEE & (sigmaIetaIeta < 0.040 & hadronicOverEm < 0.10))" #caloIdVL
#electronSelection += " & (isEB & (deltaPhiSuperClusterTrackAtVtx < 0.15 & deltaEtaSuperClusterTrackAtVtx < 0.01) | isEE & (deltaPhiSuperClusterTrackAtVtx < 0.10 & deltaEtaSuperClusterTrackAtVtx < 0.01))" #trkIdVL
electronSelection += " & gsfTrackRef().isNonnull() & gsfTrackRef().trackerExpectedHitsInner().numberOfHits() <= 0"
process.pfUnclusteredElectronsPF = cms.EDFilter(
"GenericPFCandidateSelector",
src=cms.InputTag("pfElectronsFromGoodVertex"), #pfSelectedElectronsPF
cut=cms.string(electronSelection))
process.pfElectronSequencePF.replace(
process.pfIsolatedElectronsPF, process.pfIsolatedElectronsPF +
process.goodVertices * process.pfElectronsFromGoodVertex +
process.pfUnclusteredElectronsPF + process.pfRelaxedElectronsPF)
process.patElectronsPF.pfElectronSource = "pfRelaxedElectronsPF"
process.pfNoElectronPF.topCollection = "pfUnclusteredElectronsPF"
#Muons
#relaxe built-in preselection
process.pfMuonsFromVertexPF.dzCut = 9999.0
process.pfMuonsFromVertexPF.d0Cut = 9999.0
process.pfSelectedMuonsPF.cut = ""
process.pfRelaxedMuonsPF = process.pfIsolatedMuonsPF.clone(isolationCut=3)
process.pfIsolatedMuonsPF.isolationCut = 0.15
process.pfMuonsFromGoodVertex = cms.EDFilter(
"IPCutPFCandidateSelector",
src=cms.InputTag("pfIsolatedMuonsPF"), # PFCandidate source
vertices=cms.InputTag("goodVertices"), # vertices source
d0Cut=cms.double(0.02), # transverse IP
dzCut=cms.double(1.), # longitudinal IP
d0SigCut=cms.double(99.), # transverse IP significance
dzSigCut=cms.double(99.), # longitudinal IP significance
)
muonSelection = "abs( eta ) < 2.5 & pt > 5"
#GlobalMuonPromptTight
muonSelection += " & muonRef().isNonnull & muonRef().isGlobalMuon()"
muonSelection += " & muonRef().isTrackerMuon() & muonRef().numberOfMatches > 1"
muonSelection += " & muonRef().globalTrack().normalizedChi2() < 10"
muonSelection += " & muonRef().track().numberOfValidHits() > 10"
muonSelection += " & muonRef().globalTrack().hitPattern().numberOfValidMuonHits() > 0"
muonSelection += " & muonRef().innerTrack().hitPattern().numberOfValidPixelHits() > 0"
process.pfUnclusteredMuonsPF = cms.EDFilter(
"GenericPFCandidateSelector",
src=cms.InputTag("pfMuonsFromGoodVertex"), #pfSelectedMuonsPF
cut=cms.string(muonSelection))
process.pfMuonSequencePF.replace(
process.pfIsolatedMuonsPF, process.pfIsolatedMuonsPF +
process.goodVertices * process.pfMuonsFromGoodVertex +
process.pfUnclusteredMuonsPF + process.pfRelaxedMuonsPF)
process.patMuonsPF.pfMuonSource = "pfRelaxedMuonsPF"
process.pfNoMuonPF.topCollection = "pfUnclusteredMuonsPF"
castor=cms.PSet(castorDigitizer)),
LabelPlayback=cms.string(''),
maxBunch=cms.int32(3),
minBunch=cms.int32(-2), ## in terms of 25 nsec
bunchspace=cms.int32(50), ##ns
mixProdStep1=cms.bool(False),
mixProdStep2=cms.bool(False),
playback=cms.untracked.bool(False),
useCurrentProcessOnly=cms.bool(False),
input=cms.SecSource(
"PoolSource",
type=cms.string('probFunction'),
nbPileupEvents=cms.PSet(
probFunctionVariable=cms.vint32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49),
probValue=cms.vdouble(
0, 9.31651e-08, 1.09346e-06, 5.64875e-06, 2.361e-05,
8.06074e-05, 0.000225675, 0.000558976, 0.00120977, 0.00234117,
0.00412333, 0.00670444, 0.0100845, 0.0142227, 0.0190064,
0.0240893, 0.0293227, 0.0343754, 0.0390867, 0.043246,
0.0468416, 0.0497495, 0.0519864, 0.0534802, 0.0542481,
0.0541758, 0.0533452, 0.0517044, 0.0492733, 0.0461293,
0.042412, 0.0383111, 0.0339056, 0.029475, 0.0250526, 0.0208822,
0.0170406, 0.0136212, 0.0106832, 0.00820745, 0.00616701,
0.00454278, 0.00328775, 0.00233149, 0.00162209, 0.0010969,
0.000731508, 0.000482477, 0.000309637, 0.000195411),
histoFileName=cms.untracked.string('histProbFunction.root'),
),
"MixingModule",
digitizers=cms.PSet(theDigitizers),
LabelPlayback=cms.string(''),
maxBunch=cms.int32(3),
minBunch=cms.int32(-2), ## in terms of 25 nsec
bunchspace=cms.int32(50), ##ns
mixProdStep1=cms.bool(False),
mixProdStep2=cms.bool(False),
playback=cms.untracked.bool(False),
useCurrentProcessOnly=cms.bool(False),
input=cms.SecSource(
"PoolSource",
type=cms.string('probFunction'),
nbPileupEvents=cms.PSet(
probFunctionVariable=cms.vint32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24),
probValue=cms.vdouble(0.0698146584, 0.0698146584, 0.0698146584,
0.0698146584, 0.0698146584, 0.0698146584,
0.0698146584, 0.0698146584, 0.0698146584,
0.0698146584, 0.0698146584, 0.0630151648,
0.0526654164, 0.0402754482, 0.0292988928,
0.0194384503, 0.0122016783, 0.007207042,
0.004003637, 0.0020278322, 0.0010739954,
0.0004595759, 0.0002229748, 0.0001028162,
4.58337152809607E-05),
histoFileName=cms.untracked.string('histProbFunction.root'),
seed=cms.untracked.int32(54321)),
sequential=cms.untracked.bool(False),
fileNames=FileNames),
mixObjects=cms.PSet(theMixObjects))
def loadPAT(process, jetMetCorrections, extMatch):
#-- Changes for electron and photon ID ----------------------------------------
from PhysicsTools.PatAlgos.tools.pfTools import usePFIso
usePFIso(process)
process.patElectrons.isolationValues = cms.PSet(
pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03PFIdPFIso"),
pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03PFIdPFIso"),
pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03PFIdPFIso"),
pfPhotons=cms.InputTag("elPFIsoValueGamma03PFIdPFIso"),
pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03PFIdPFIso"))
process.patElectrons.isolationValuesNoPFId = cms.PSet(
pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03NoPFIdPFIso"),
pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03NoPFIdPFIso"),
pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03NoPFIdPFIso"),
pfPhotons=cms.InputTag("elPFIsoValueGamma03NoPFIdPFIso"),
pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03NoPFIdPFIso"))
process.patDefaultSequence.replace(
process.patElectrons, process.eleIsoSequence + process.patElectrons)
process.patDefaultSequence.replace(
process.patMuons, process.muIsoSequence + process.patMuons)
# Turn off photon-electron cleaning (i.e., flag only)
process.cleanPatPhotons.checkOverlaps.electrons.requireNoOverlaps = False
# Embed tracks, since we drop them
process.patElectrons.embedTrack = True
process.patMuons.embedTrack = True
#include tau decay mode in pat::Taus (elese it will just be uninitialized)
#decay modes are dropped and have to be redone, this is a bit dangorous since the decay modes insered are *not* the ones used in RECO
#process.patTaus.addDecayMode = True
#process.makePatTaus.replace( process.patTaus, process.shrinkingConePFTauDecayModeProducer + process.patTaus )
#Additional electron ids as defined for VBTF
process.load("ElectroWeakAnalysis.WENu.simpleEleIdSequence_cff")
process.patElectrons.electronIDSources = cms.PSet(
eidTight=cms.InputTag("eidTight"),
eidLoose=cms.InputTag("eidLoose"),
eidRobustTight=cms.InputTag("eidRobustTight"),
eidRobustHighEnergy=cms.InputTag("eidRobustHighEnergy"),
eidRobustLoose=cms.InputTag("eidRobustLoose"),
simpleEleId95relIso=cms.InputTag("simpleEleId95relIso"),
simpleEleId90relIso=cms.InputTag("simpleEleId90relIso"),
simpleEleId85relIso=cms.InputTag("simpleEleId85relIso"),
simpleEleId80relIso=cms.InputTag("simpleEleId80relIso"),
simpleEleId70relIso=cms.InputTag("simpleEleId70relIso"),
simpleEleId60relIso=cms.InputTag("simpleEleId60relIso"),
simpleEleId95cIso=cms.InputTag("simpleEleId95cIso"),
simpleEleId90cIso=cms.InputTag("simpleEleId90cIso"),
simpleEleId85cIso=cms.InputTag("simpleEleId85cIso"),
simpleEleId80cIso=cms.InputTag("simpleEleId80cIso"),
simpleEleId70cIso=cms.InputTag("simpleEleId70cIso"),
simpleEleId60cIso=cms.InputTag("simpleEleId60cIso"))
process.patDefaultSequence.replace(
process.patElectrons,
process.simpleEleIdSequence + process.patElectrons)
#-- Tuning of Monte Carlo matching --------------------------------------------
# Also match with leptons of opposite charge
process.electronMatch.checkCharge = False
process.electronMatch.maxDeltaR = cms.double(0.2)
process.electronMatch.maxDPtRel = cms.double(999999.)
process.muonMatch.checkCharge = False
process.muonMatch.maxDeltaR = cms.double(0.2)
process.muonMatch.maxDPtRel = cms.double(999999.)
#process.tauMatch.checkCharge = False
#process.tauMatch.maxDeltaR = cms.double(0.3)
process.patJetPartonMatch.maxDeltaR = cms.double(0.25)
process.patJetPartonMatch.maxDPtRel = cms.double(999999.)
process.patJetGenJetMatch.maxDeltaR = cms.double(0.25)
process.patJetGenJetMatch.maxDPtRel = cms.double(999999.)
if extMatch:
process.electronMatch.mcStatus = cms.vint32(1, 5)
process.electronMatch.matched = "mergedTruth"
process.muonMatch.mcStatus = cms.vint32(1, 5)
process.muonMatch.matched = "mergedTruth"
process.patJetPartonMatch.matched = "mergedTruth"
process.patJetPartons.src = "mergedTruth"
process.photonMatch.matched = "mergedTruth"
#process.tauGenJets.GenParticles = "mergedTruth"
#process.tauMatch.matched = "mergedTruth"
#-- Taus ----------------------------------------------------------------------
#some tau discriminators have been switched off during development. They can be switched on again...
#setattr(process.patTaus.tauIDSources, "trackIsolation", cms.InputTag("shrinkingConePFTauDiscriminationByTrackIsolation"))
#setattr(process.patTaus.tauIDSources, "ecalIsolation", cms.InputTag("shrinkingConePFTauDiscriminationByECALIsolation"))
#setattr(process.patTaus.tauIDSources, "byIsolation", cms.InputTag("shrinkingConePFTauDiscriminationByIsolation"))
#setattr(process.patTaus.tauIDSources, "leadingPionPtCut", cms.InputTag("shrinkingConePFTauDiscriminationByLeadingPionPtCut"))
#setattr(process.patTaus.tauIDSources, "trackIsolationUsingLeadingPion", cms.InputTag("shrinkingConePFTauDiscriminationByTrackIsolationUsingLeadingPion"))
#setattr(process.patTaus.tauIDSources, "ecalIsolationUsingLeadingPion", cms.InputTag("shrinkingConePFTauDiscriminationByECALIsolationUsingLeadingPion"))
#setattr(process.patTaus.tauIDSources, "byIsolationUsingLeadingPion", cms.InputTag("shrinkingConePFTauDiscriminationByIsolationUsingLeadingPion"))
#setattr(process.patTaus.tauIDSources, "byTaNC", cms.InputTag("shrinkingConePFTauDiscriminationByTaNC"))
#setattr(process.patTaus.tauIDSources, "byTaNCfrOnePercent", cms.InputTag("shrinkingConePFTauDiscriminationByTaNCfrOnePercent"))
#setattr(process.patTaus.tauIDSources, "byTaNCfrHalfPercent", cms.InputTag("shrinkingConePFTauDiscriminationByTaNCfrHalfPercent"))
#setattr(process.patTaus.tauIDSources, "byTaNCfrQuarterPercent", cms.InputTag("shrinkingConePFTauDiscriminationByTaNCfrQuarterPercent"))
#setattr(process.patTaus.tauIDSources, "byTaNCfrTenthPercent", cms.InputTag("shrinkingConePFTauDiscriminationByTaNCfrTenthPercent"))
#-- Jet corrections -----------------------------------------------------------
# L1 FastJet jet corrections
# kt6PFJets for FastJet corrections are already run and placed before jetCorrection calculation
# apply FastJet corrections only if demanded
# TODO: Check if still necessary to switch here
if ("L1FastJet" in jetMetCorrections):
process.pfJets.doAreaFastjet = True
process.pfJetsPF.doAreaFastjet = True
process.genstepfilter.triggerConditions = cms.vstring("generation_step")
process.mix.digitizers = cms.PSet(process.theDigitizersValid)
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag,
'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)
from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toReplaceWith(generalTracksTask,
cms.Task(
duplicateTrackCandidates,
mergedDuplicateTracks,
duplicateTrackClassifier
)
)
def _fastSimGeneralTracks(process):
from FastSimulation.Configuration.DigiAliases_cff import loadDigiAliasesWasCalled
if loadDigiAliasesWasCalled:
from FastSimulation.Configuration.DigiAliases_cff import generalTracks
process.generalTracks = generalTracks
return
from Configuration.StandardSequences.Digi_cff import generalTracks
process.generalTracks = generalTracks
modifyMergeTrackCollections_fastSimGeneralTracks = fastSim.makeProcessModifier( _fastSimGeneralTracks )
import RecoTracker.FinalTrackSelectors.trackListMerger_cfi
conversionStepTracks = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone(
TrackProducers = cms.VInputTag(cms.InputTag('convStepTracks')),
hasSelector=cms.vint32(1),
selectedTrackQuals = cms.VInputTag(cms.InputTag("convStepSelector","convStep")
),
setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(1), pQual=cms.bool(True) )
),
copyExtras = True,
makeReKeyedSeeds = cms.untracked.bool(False)
)
doLepPtFilter = cms.untracked.bool(True), hadPt = cms.untracked.double(18), lepPt = cms.untracked.double(15), doEtaFilter = cms.untracked.bool(True), MaxEta = cms.untracked.double(2.5), MinEta = cms.untracked.double(-2.5), NFilterTests = cms.untracked.int32(10000), InputCards = cms.PSet( mdtau = cms.int32(0), pjak2 = cms.int32(0), pjak1 = cms.int32(0) ), setTauBr = cms.PSet( JAK = cms.vint32(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22), BR = cms.vdouble(0.0, 0.1741, 0.1832, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) #BR = cms.vdouble(0.0, 0.1741, 0.0, 0.0, 0.1832, # 0.0, 0.0, 0.0448, 0.0105, 0.0, # 0.0, 0.0, 0.0, 0.00144, 0.0, # 0.0, 0.0, 0.00294, 0.0, 0.0, # 0.0, 0.0) ) ) ),
# 'TrackerTPEModule,111001',
# 'TrackerTIBModuleUnit,101111',
# 'TrackerTIDModuleUnit,101111',
# 'TrackerTECModuleUnit,101111,tecSingleSens'
# ,'TrackerTOBModuleUnit,101111',
)
)
process.AlignmentProducer.ParameterBuilder.SelectorBowed = cms.PSet(
alignParams = cms.vstring(
'TrackerTPBModule,111111 111',
'TrackerTPEModule,111001 000', # could do with rigid body...
'TrackerTIBModuleUnit,101111 111',
'TrackerTIDModuleUnit,101111 111',
'TrackerTECModuleUnit,101111 111,tecSingleSens'
),
tecSingleSens = cms.PSet(tecDetId = cms.PSet(ringRanges = cms.vint32(1,4)))
)
process.AlignmentProducer.ParameterBuilder.Selector2Bowed = cms.PSet(
alignParams = cms.vstring(
'TrackerTOBModuleUnit,101111 111 101111 111',
'TrackerTECModuleUnit,101111 111 101111 111,tecDoubleSens'
),
tecDoubleSens = cms.PSet(tecDetId = cms.PSet(ringRanges = cms.vint32(5,7)))
)
#process.AlignmentProducer.doMuon = True # to align muon system
process.AlignmentProducer.doMisalignmentScenario = False #True
# If the above is true, you might want to choose the scenario:
#from Alignment.TrackerAlignment.Scenarios_cff import *
#process.AlignmentProducer.MisalignmentScenario = TrackerSurveyLASOnlyScenario
process.AlignmentProducer.applyDbAlignment = False # neither globalTag nor trackerAlignment
),
detachedTripletStepSelector.trackSelectors[4].clone(
name='initialStepV2',
preFilterName=cms.string(''),
keepAllTracks=cms.bool(False)),
detachedTripletStepSelector.trackSelectors[5].clone(
name='initialStepV3',
preFilterName=cms.string(''),
keepAllTracks=cms.bool(False))) #end of vpset
) #end of clone
import RecoTracker.FinalTrackSelectors.trackListMerger_cfi
initialStep = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone(
TrackProducers=cms.VInputTag(cms.InputTag('initialStepTracks'),
cms.InputTag('initialStepTracks'),
cms.InputTag('initialStepTracks')),
hasSelector=cms.vint32(1, 1, 1),
shareFrac=cms.double(0.99),
indivShareFrac=cms.vdouble(1.0, 1.0, 1.0),
selectedTrackQuals=cms.VInputTag(
cms.InputTag("initialStepSelector", "initialStepV1"),
cms.InputTag("initialStepSelector", "initialStepV2"),
cms.InputTag("initialStepSelector", "initialStepV3")),
setsToMerge=cms.VPSet(
cms.PSet(tLists=cms.vint32(0, 1, 2), pQual=cms.bool(True))),
writeOnlyTrkQuals=cms.bool(True))
# Final sequence
InitialStep = cms.Sequence(initialStepSeedLayers * initialStepSeeds *
initialStepTrackCandidates * initialStepTracks *
firstStepPrimaryVertices * initialStepSelector *
initialStep)
#https://cmssdt.cern.ch/lxr/source/IOMC/ParticleGuns/src/CloseByParticleGunProducer.cc
import FWCore.ParameterSet.Config as cms
process.generator = cms.EDProducer(
"CloseByParticleGunProducer",
PGunParameters=cms.PSet(
PartID=cms.vint32(22, 22),
NParticles=cms.int32(1),
EnMin=cms.double(1.), # in GeV
EnMax=cms.double(100.),
RMin=cms.double(123.8), # in cm
RMax=cms.double(123.8),
ZMin=cms.double(-304.5), # in cm
ZMax=cms.double(304.5),
Delta=cms.double(
300
), # in cm -> phi1-phi2 = Delta/R # for NParticles=1 irrelevant
Pointing=cms.bool(
True), # otherwise showers parallel/perpendicular to beam axis
Overlapping=cms.bool(False),
RandomShoot=cms.bool(False),
MaxPhi=cms.double(3.14159265359),
MinPhi=cms.double(-3.14159265359),
MaxEta=cms.double(0.), # dummy, it is not used
MinEta=cms.double(0.), # dummy, it is not used
),
Verbosity=cms.untracked.int32(1),
psethack=cms.string('two particles close to EB'),
AddAntiParticle=cms.bool(False),
firstRun=cms.untracked.uint32(1))
metSource = cms.InputTag("patMETs"),
muonSource = cms.InputTag("selectedPatMuons"),
electronSource = cms.InputTag("selectedPatElectrons"),
jetSource = cms.InputTag("selectedPatJets"),
## lepton flavor
leptonFlavour = cms.string('muon'),
## choose jet correction scheme
jetCorrectionScheme = cms.int32(0),
## match to gen event?
matchToGenEvt = cms.bool(False),
## configuration of kinemtaic fit
doKinFit = cms.bool(True),
maxNrIter = cms.int32(200),
maxDeltaS = cms.double(5e-05),
maxF = cms.double(0.0001),
constraints = cms.vint32(1, 2),
jetParametrisation = cms.int32(0),
metParametrisation = cms.int32(0),
lepParametrisation = cms.int32(0),
## configuration of private LH ratio method
addLRJetComb = cms.bool(False),
lrJetCombFile = cms.string('TopQuarkAnalysis/TopJetCombination/data/to_be_added.root')
)
G4cerr=cms.untracked.PSet(limit=cms.untracked.int32(-1)),
HCalGeom=cms.untracked.PSet(limit=cms.untracked.int32(-1))),
)
process.RandomNumberGeneratorService = cms.Service(
"RandomNumberGeneratorService",
moduleSeeds=cms.PSet(generator=cms.untracked.uint32(456789),
g4SimHits=cms.untracked.uint32(9876),
VtxSmeared=cms.untracked.uint32(12345)),
sourceSeed=cms.untracked.uint32(98765))
process.source = cms.Source("EmptySource")
process.generator = cms.EDProducer("FlatRandomEGunProducer",
PGunParameters=cms.PSet(
PartID=cms.vint32(14),
MinEta=cms.double(-3.5),
MaxEta=cms.double(3.5),
MinPhi=cms.double(-3.14159265359),
MaxPhi=cms.double(3.14159265359),
MinE=cms.double(9.99),
MaxE=cms.double(10.01)),
AddAntiParticle=cms.bool(False),
Verbosity=cms.untracked.int32(0),
firstRun=cms.untracked.uint32(1))
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1))
process.p1 = cms.Path(process.generator * process.g4SimHits)
process.g4SimHits.UseMagneticField = False
process.g4SimHits.Physics.type = 'SimG4Core/Physics/DummyPhysics'
filterName=cms.untracked.string('')),
fileName=cms.untracked.string('file:step1.root'),
outputCommands=process.FEVTDEBUGEventContent.outputCommands,
splitLevel=cms.untracked.int32(0))
# Additional output definition
# Other statements
process.genstepfilter.triggerConditions = cms.vstring("generation_step")
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic', '')
process.generator = cms.EDProducer(
"CloseByParticleGunProducer",
PGunParameters=cms.PSet(
PartID=cms.vint32(options.pdgId, options.pdgId),
En=cms.double(50.),
R=cms.double(options.deltaR),
MinEta=cms.double(1.5), #dummy values
MaxEta=cms.double(2.9),
MinPhi=cms.double(-3.1415),
MaxPhi=cms.double(+3.1415)),
Verbosity=cms.untracked.int32(0),
psethack=cms.string('two close by particles'),
AddAntiParticle=cms.bool(False),
firstRun=cms.untracked.uint32(1))
#process.generator = cms.EDProducer("FlatRandomEGunProducer",
# AddAntiParticle = cms.bool(False),
# PGunParameters = cms.PSet(MaxE = cms.double(50.01),
# MaxEta = cms.double(2.9),
"hpsPFTauDiscriminationByTightMuonRejection3"),
antiEleInputTag=cms.untracked.InputTag(
"hpsPFTauDiscriminationByMVA6LooseElectronRejection"),
decayModeFindingInputTag=cms.untracked.InputTag(
"hpsPFTauDiscriminationByDecayModeFindingOldDMs"),
comb3TInputTag=cms.untracked.InputTag(
"hpsPFTauDiscriminationByTightCombinedIsolationDBSumPtCorr3Hits"),
l1tInputTag=cms.untracked.InputTag("caloStage2Digis:Tau"),
vtxInputTag=cms.untracked.InputTag("offlinePrimaryVertices"),
bsInputTag=cms.untracked.InputTag("offlineBeamSpot"),
triggerNames=cms.untracked.vstring("HLT_IsoMu18_v*", "HLT_IsoMu20_v*",
"HLT_IsoMu22_v*", "HLT_IsoMu24_v*",
"HLT_IsoMu27_v*"),
trigInputTag=cms.untracked.InputTag("hltTriggerSummaryAOD", "", "HLT"),
trigProcess=cms.untracked.string("HLT"),
trigProcess_token=cms.untracked.InputTag("TriggerResults", "", "HLT"),
histFolder=cms.string('L1T/L1TObjects/L1TTau/L1TriggerVsReco'),
tauEfficiencyThresholds=cms.vint32(tauEfficiencyThresholds),
tauEfficiencyBins=cms.vdouble(tauEfficiencyBins),
histDefinitions=cms.PSet(
nVertex=histDefinitions.nVertex.clone(),
ETvsET=histDefinitions.ETvsET.clone(),
PHIvsPHI=histDefinitions.PHIvsPHI.clone(),
),
)
l1tTauOfflineDQMEmu = l1tTauOfflineDQM.clone(
stage2CaloLayer2TauSource=cms.InputTag("simCaloStage2Digis"),
histFolder=cms.string('L1TEMU/L1TObjects/L1TTau/L1TriggerVsReco'),
)
dz_par1=(0.9, 4.0),
d0_par2=(0.9, 4.0),
dz_par2=(0.9, 4.0))
] #end of vpset
) #end of clone
from RecoTracker.FinalTrackSelectors.trackAlgoPriorityOrder_cfi import trackAlgoPriorityOrder
import RecoTracker.FinalTrackSelectors.trackListMerger_cfi
_trackListMergerBase = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone(
TrackProducers=['mixedTripletStepTracks', 'mixedTripletStepTracks'],
hasSelector=[1, 1],
selectedTrackQuals=[
cms.InputTag("mixedTripletStepSelector", "mixedTripletStepVtx"),
cms.InputTag("mixedTripletStepSelector", "mixedTripletStepTrk")
],
setsToMerge=[cms.PSet(tLists=cms.vint32(0, 1), pQual=cms.bool(True))],
writeOnlyTrkQuals=True)
trackingLowPU.toReplaceWith(mixedTripletStep, _trackListMergerBase)
MixedTripletStep = cms.Sequence(
chargeCut2069Clusters * mixedTripletStepClusters *
mixedTripletStepSeedLayersA * mixedTripletStepTrackingRegionsA *
mixedTripletStepHitDoubletsA * mixedTripletStepHitTripletsA *
mixedTripletStepSeedsA * mixedTripletStepSeedLayersB *
mixedTripletStepTrackingRegionsB * mixedTripletStepHitDoubletsB *
mixedTripletStepHitTripletsB * mixedTripletStepSeedsB *
mixedTripletStepSeeds * mixedTripletStepTrackCandidates *
mixedTripletStepTracks * mixedTripletStepClassifier1 *
mixedTripletStepClassifier2 * mixedTripletStep)
_MixedTripletStep_LowPU = MixedTripletStep.copyAndExclude(
[chargeCut2069Clusters, mixedTripletStepClassifier1])
import FWCore.ParameterSet.Config as cms
from Configuration.Generator.Pythia8CommonSettings_cfi import *
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *
from GeneratorInterface.EvtGenInterface.EvtGenSetting_cff import *
generator = cms.EDFilter(
"Pythia8GeneratorFilter",
pythiaPylistVerbosity=cms.untracked.int32(0),
pythiaHepMCVerbosity=cms.untracked.bool(False),
comEnergy=cms.double(5020.0),
maxEventsToPrint=cms.untracked.int32(0),
ExternalDecays=cms.PSet(EvtGen130=cms.untracked.PSet(
decay_table=cms.string(
'GeneratorInterface/EvtGenInterface/data/DECAY_2010.DEC'),
operates_on_particles=cms.vint32(),
particle_property_file=cms.FileInPath(
'GeneratorInterface/EvtGenInterface/data/evt.pdl'),
list_forced_decays=cms.vstring('MyD_s+', 'MyD_s-'),
user_decay_embedded=cms.vstring("""
Alias MyD_s+ D_s+
Alias MyD_s- D_s-
ChargeConj MyD_s- MyD_s+
Alias Myphi phi
Decay MyD_s+
1.000 Myphi pi+ SVS;
Enddecay
CDecay MyD_s-
Decay Myphi
1.000 K+ K- VSS;
Enddecay
End
# Input source
process.source = cms.Source("EmptySource")
process.options = cms.untracked.PSet()
process.RandomNumberGeneratorService.pregenerator = cms.PSet(
initialSeed=cms.untracked.uint32(932751),
engineName=cms.untracked.string('HepJamesRandom'))
#process.pregenerator = cms.EDProducer("FlatRapidFlatPtGunProducer",
process.pregenerator = cms.EDProducer(
"FlatRapidMeasuredPtGunProducer",
PGunParameters=cms.PSet(
# you can request more than 1 particle
PartID=cms.vint32(200553),
MinRapidity=cms.untracked.double(-1.3),
MaxRapidity=cms.untracked.double(1.3),
#
# phi must be given in radians
#
##for some reason these are tracked now...this gun doesnt use eta though
MinEta=cms.double(0),
MaxEta=cms.double(0),
MinPhi=cms.double(-3.14159265358979323846),
MaxPhi=cms.double(3.14159265358979323846),
MinPt=cms.double(0),
MaxPt=cms.double(50),
Resonance=cms.untracked.double(3),
),
AddAntiParticle=cms.bool(False),
ActiveBoardsMask=cms.uint32(0xffff),
DaqGtInputTag=cms.InputTag("rawDataCollector"))
fragment.hltCaloStage1Digis = cms.EDProducer(
"L1TRawToDigi",
lenSlinkTrailer=cms.untracked.int32(8),
lenAMC13Header=cms.untracked.int32(8),
CTP7=cms.untracked.bool(False),
lenAMC13Trailer=cms.untracked.int32(8),
Setup=cms.string("stage1::CaloSetup"),
MinFeds=cms.uint32(0),
InputLabel=cms.InputTag("rawDataCollector"),
lenSlinkHeader=cms.untracked.int32(8),
MTF7=cms.untracked.bool(False),
FWId=cms.uint32(4294967295),
debug=cms.untracked.bool(False),
FedIds=cms.vint32(1352),
lenAMCHeader=cms.untracked.int32(8),
lenAMCTrailer=cms.untracked.int32(0),
FWOverride=cms.bool(False))
fragment.hltCaloStage1LegacyFormatDigis = cms.EDProducer(
"L1TCaloUpgradeToGCTConverter",
InputHFCountsCollection=cms.InputTag('hltCaloStage1Digis', 'HFBitCounts'),
InputHFSumsCollection=cms.InputTag('hltCaloStage1Digis', 'HFRingSums'),
bxMin=cms.int32(0),
bxMax=cms.int32(0),
InputCollection=cms.InputTag("hltCaloStage1Digis"),
InputIsoTauCollection=cms.InputTag('hltCaloStage1Digis', 'isoTaus'),
InputRlxTauCollection=cms.InputTag('hltCaloStage1Digis', 'rlxTaus'))
fragment.hltL1GtObjectMap = cms.EDProducer(
"L1GlobalTrigger",
TechnicalTriggersUnprescaled=cms.bool(True),
destinations=cms.untracked.vstring('cout'))
process.load("IOMC.RandomEngine.IOMC_cff")
process.RandomNumberGeneratorService.generator.initialSeed = 456789
process.RandomNumberGeneratorService.g4SimHits.initialSeed = 9876
process.RandomNumberGeneratorService.VtxSmeared.initialSeed = 123456789
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(20))
process.source = cms.Source("EmptySource",
firstRun=cms.untracked.uint32(1),
firstEvent=cms.untracked.uint32(1))
process.generator = cms.EDProducer("FlatRandomEGunProducer",
PGunParameters=cms.PSet(
PartID=cms.vint32(211),
MinEta=cms.double(-5.5),
MaxEta=cms.double(5.5),
MinPhi=cms.double(-3.14159265359),
MaxPhi=cms.double(3.14159265359),
MinE=cms.double(99.99),
MaxE=cms.double(100.01)),
Verbosity=cms.untracked.int32(0),
AddAntiParticle=cms.bool(False))
process.output = cms.OutputModule(
"PoolOutputModule",
process.FEVTSIMEventContent,
fileName=cms.untracked.string('simevent.root'))
process.Timing = cms.Service("Timing")
binOfMaximum=cms.int32(6), ## optional from release 200 on, from 1-10
)
# ECAL rechits and co
process.load("Configuration/StandardSequences/Reconstruction_cff")
#Changed on 15/10/18. Changed algorithm to multifit.
#import RecoLocalCalo.EcalRecProducers.ecalGlobalUncalibRecHit_cfi
#process.ecalUncalibHit = RecoLocalCalo.EcalRecProducers.ecalGlobalUncalibRecHit_cfi.ecalGlobalUncalibRecHit.clone()
#------------------------
import RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi
process.ecalUncalibHit = RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi.ecalMultiFitUncalibRecHit.clone(
)
process.ecalUncalibHit.algoPSet.activeBXs = cms.vint32(-5, -4, -3, -2, -1, 0,
1, 2, 3, 4)
process.ecalUncalibHit.algoPSet.useLumiInfoRunHeader = cms.bool(False)
#--------------------------
process.load("RecoLocalCalo.EcalRecProducers.ecalRecHit_cfi")
process.load("Geometry.CaloEventSetup.CaloTopology_cfi")
process.load("RecoLocalCalo.EcalRecProducers.ecalDetIdToBeRecovered_cfi")
process.ecalRecHit.EBuncalibRecHitCollection = 'ecalUncalibHit:EcalUncalibRecHitsEB'
process.ecalRecHit.EEuncalibRecHitCollection = 'ecalUncalibHit:EcalUncalibRecHitsEE'
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1))
process.source = cms.Source("PoolSource",
fileNames=(cms.untracked.vstring(
options.inputfile)))
# process.MessageLogger.categories.append('HitStudy')
process.load("IOMC.RandomEngine.IOMC_cff")
process.RandomNumberGeneratorService.generator.initialSeed = 456789
process.RandomNumberGeneratorService.g4SimHits.initialSeed = 9876
process.RandomNumberGeneratorService.VtxSmeared.initialSeed = 123456789
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(5000))
process.source = cms.Source("EmptySource",
firstRun=cms.untracked.uint32(1),
firstEvent=cms.untracked.uint32(1))
process.generator = cms.EDProducer("FlatRandomEGunProducer",
PGunParameters=cms.PSet(
PartID=cms.vint32(11),
MinEta=cms.double(-2.9),
MaxEta=cms.double(2.9),
MinPhi=cms.double(-3.14159265359),
MaxPhi=cms.double(3.14159265359),
MinE=cms.double(100.),
MaxE=cms.double(100.)),
Verbosity=cms.untracked.int32(0),
AddAntiParticle=cms.bool(False))
process.TFileService = cms.Service("TFileService",
fileName=cms.string('electron100.root'))
process.generation_step = cms.Path(process.pgen)
process.simulation_step = cms.Path(process.psim)
process.analysis_step = cms.Path(process.EcalSimHitStudy)
#Create the PU candidates
pfPileUpCandidates = cms.EDProducer(
"TPPFCandidatesOnPFCandidates",
enable=cms.bool(True),
verbose=cms.untracked.bool(False),
name=cms.untracked.string("pileUpCandidates"),
topCollection=cms.InputTag("pfNoPileUp"),
### bottomCollection = cms.InputTag("particleFlowTmp") ## ..Tmp in 44X
bottomCollection=cms.InputTag("particleFlow"),
)
#Take the PU charged particles
pfPUChargedCandidates = cms.EDFilter("PdgIdPFCandidateSelector",
src=cms.InputTag("pfPileUpCandidates"),
pdgId=cms.vint32(211, -211, 321, -321,
999211, 2212, -2212, 11,
-11, 13, -13))
#Create All Charged Particles
pfAllChargedCandidates = cms.EDFilter("PdgIdPFCandidateSelector",
src=cms.InputTag("pfNoPileUp"),
pdgId=cms.vint32(211, -211, 321, -321,
999211, 2212, -2212, 11,
-11, 13, -13))
pfPileUpCandidatesSequence = cms.Sequence(pfPileUpCandidates +
pfPUChargedCandidates +
pfAllChargedCandidates)
pfCandsForIsolationSequence = cms.Sequence(pfNoPileUpSequence +
pfSortByTypeSequence +
dataTier = cms.untracked.string('GEN-SIM-DIGI-RAW-RECO')
),
SelectEvents = cms.untracked.PSet(
SelectEvents = cms.vstring('generation_step')
)
)
# Additional output definition
process.g4SimHits.Watchers = cms.VPSet(cms.PSet(
SimG4HGCalValidation = cms.PSet(
Names = cms.vstring(
'HGCalEECell',
'HGCalHECell',
'HEScintillator',
),
Types = cms.vint32(1,1,2),
DetTypes = cms.vint32(0,1,2),
LabelLayerInfo = cms.string("HGCalInfoLayer"),
Verbosity = cms.untracked.int32(0),
),
type = cms.string('SimG4HGCalValidation')
))
# Other statements
process.genstepfilter.triggerConditions=cms.vstring("generation_step")
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic', '')
process.generator = cms.EDProducer("FlatRandomPtGunProducer",
PGunParameters = cms.PSet(
MaxPt = cms.double(20.0),
pythia8CommonSettingsBlock,
pythia8CUEP8M1SettingsBlock,
processParameters=cms.vstring(
'ExtraDimensionsG*:all = on',
'ExtraDimensionsG*:kappaMG = 0.54',
'5100039:m0 = 2500',
'5100039:onMode = off',
'5100039:onIfAny = 24',
),
parameterSets=cms.vstring(
'pythia8CommonSettings',
'pythia8CUEP8M1Settings',
'processParameters')))
llgenfilter = cms.EDFilter("MCMultiParticleFilter",
Status=cms.vint32(23, 23),
src=cms.InputTag('generator'),
ParticleID=cms.vint32(11, 13),
PtMin=cms.vdouble(0, 0),
NumRequired=cms.int32(1),
EtaMax=cms.vdouble(9999, 9999),
AcceptMore=cms.bool(True))
qqgenfilter = cms.EDFilter("MCMultiParticleFilter",
Status=cms.vint32(23, 23, 23, 23, 23),
src=cms.InputTag('generator'),
ParticleID=cms.vint32(1, 2, 3, 4, 5),
PtMin=cms.vdouble(0, 0, 0, 0, 0),
NumRequired=cms.int32(1),
EtaMax=cms.vdouble(9999, 9999, 9999, 9999, 9999),
AcceptMore=cms.bool(True))
# to include:
#
from PhysicsTools.HepMCCandAlgos.genParticles_cfi import *
genParticles.abortOnUnknownPDGCode = cms.untracked.bool(False)
# The H0 must have a small coupling to SM particles in order to be produced.
# This means that it occassionally decays to them. The following filter
# rejects these decays (and prints statistics).
genParticlesForFilter = genParticles.clone()
from GeneratorInterface.GenFilters.XtoFFbarFilter_cfi import *
XtoFFbarFilter.src = cms.InputTag("genParticlesForFilter")
# Specify PDG codes of exotics to be accepted by filter.
XtoFFbarFilter.idMotherX = cms.vint32(6000111, 6000112, 6000113, 6000114,
6001111, 6001112, 6001113, 6001114,
6002111, 6002112, 6002113, 6002114,
6003111, 6003112, 6003113, 6003114)
XtoFFbarFilter.idMotherY = cms.vint32(6000111, 6000112, 6000113, 6000114,
6001111, 6001112, 6001113, 6001114,
6002111, 6002112, 6002113, 6002114,
6003111, 6003112, 6003113, 6003114)
# To be defined in file that imports this one.
#ProductionFilterSequence = cms.Sequence(generator*genParticlesForFilter*XtoFFbarFilter)
#
#== However, some Pythia parameters are tailored below for the specific generation wanted here.
#
# Centre of mass energy
generator.comEnergy = cms.double(COM_ENERGY)
