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