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)