def customizeJetSystematicsForData(process): # By default remove the systematic entirely # For JEC, re-do central value in case the global tag has been updated process.jec.toGet[0].tag = cms.string(process.jec.toGet[0].tag.value().replace("MC","DATA")) process.jec.connect = cms.string(process.jec.connect.value().replace("MC","DATA")) from flashgg.Taggers.flashggTags_cff import UnpackedJetCollectionVInputTag jetsystprodlist = [getattr(process,"flashggJetSystematics%i"%i) for i in range(len(UnpackedJetCollectionVInputTag))] for systprod in jetsystprodlist: # For updating bugged or unavailable JEC # It should be a noop in cases where they are already correct newvpset = cms.VPSet() for pset in systprod.SystMethods: if pset.Label.value().count("JEC"): pset.NSigmas = cms.vint32() # Do not perform shifts, central value only pset.SetupUncertainties = False pset.JetCorrectorTag = cms.InputTag("ak4PFCHSL1FastL2L3ResidualCorrector") newvpset += [pset] systprod.SystMethods = newvpset process.load("JetMETCorrections/Configuration/JetCorrectionServices_cff") process.jetCorrectorChain = cms.Sequence(process.ak4PFCHSL1FastL2L3ResidualCorrectorChain) #hopefully a temporary hack (2016 data) # from os import environ # process.jec.connect = cms.string('sqlite_file:%s/src/flashgg/Systematics/data/JEC/Summer16_23Sep2016AllV4_DATA.db' % environ['CMSSW_BASE']) # process.jec.toGet[0].tag = cms.string('JetCorrectorParametersCollection_Summer16_23Sep2016AllV4_DATA_AK4PFchs') # Update this hack for 2017 data from os import environ process.jec.connect = cms.string('sqlite_file:%s/src/flashgg/Systematics/data/JEC/Fall17_17Nov2017BCDEF_V6_DATA.db' % environ['CMSSW_BASE']) process.jec.toGet[0].tag = cms.string('JetCorrectorParametersCollection_Fall17_17Nov2017BCDEF_V6_DATA_AK4PFchs')
def customise_pu_protons_ctpps(process): process=customise(process) process.mix.mixObjects.mixHepMC.makeCrossingFrame = cms.untracked.bool(True) process.ppssim.UseHepMCProducer = cms.untracked.bool(False) # PU gen particle process.genParticlesPU = cms.EDProducer("GenParticleProducer", saveBarCodes = cms.untracked.bool(True), mix = cms.string("mix"), abortOnUnknownPDGCode = cms.untracked.bool(False), useCrossingFrame = cms.untracked.bool(True) ) process.genProtonsPU = cms.EDFilter("GenParticleSelector", filter = cms.bool(False), src = cms.InputTag("genParticlesPU"), cut = cms.string('') ) process.genProtonsPU.cut = 'status = 1 & pdgId == 2212 & abs(pz) >= %f' % ( 0.5*13000./2.0) outputCommandsPU = [ 'keep *_genParticlesPU_*_*', 'keep *_genProtonsPU_*_*'] process.ppssim.genSource = cms.InputTag("genProtonsPU") # for Pile-up events #process.digitisation_step.replace(process.pdigi_valid, process.pdigi_valid * process.genParticlesPU * process.genProtonsPU) process.digitisation_step.replace(process.ppssim, process.genParticlesPU * process.genProtonsPU * process.ppssim) return (process)
def addHLT(self,path,triggerProcess,summaryText = ''): hltSkimmer = cms.EDFilter("HLTHighLevel", TriggerResultsTag = cms.InputTag("TriggerResults","",triggerProcess), HLTPaths = cms.vstring(path), # provide list of HLT paths (or patterns) you want eventSetupPathsKey = cms.string(''), # not empty => use read paths from AlCaRecoTriggerBitsRcd via this key andOr = cms.bool(True), # how to deal with multiple triggers: True (OR) accept if ANY is true, False (AND) accept if ALL are true throw = cms.bool(True) # throw exception on unknown path names ) pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,'hltSkimmer',hltSkimmer) self.sequence*=hltSkimmer #now the counter if summaryText is not '': counter = cms.EDProducer("EventCounter") counter.name=cms.string(summaryText) counter.setLabel('hltSkimmerCounter') pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,'hltSkimmerCounter',counter) self.sequence*=counter
def customiseDataRun2Common(process): if hasattr(process,'CSCGeometryESModule'): process.CSCGeometryESModule.useGangedStripsInME1a = cms.bool(False) if hasattr(process,'CSCIndexerESProducer'): process.CSCIndexerESProducer.AlgoName=cms.string("CSCIndexerPostls1") if hasattr(process,'CSCChannelMapperESProducer'): process.CSCChannelMapperESProducer.AlgoName=cms.string("CSCChannelMapperPostls1") if hasattr(process,'csc2DRecHits'): process.csc2DRecHits.readBadChannels = cms.bool(False) process.csc2DRecHits.CSCUseGasGainCorrections = cms.bool(False) if hasattr(process,'valCscTriggerPrimitiveDigis'): #this is not doing anything at the moment process.valCscTriggerPrimitiveDigis.commonParam.gangedME1a = cms.bool(False) if hasattr(process,'valCsctfTrackDigis'): process.valCsctfTrackDigis.gangedME1a = cms.untracked.bool(False) from SLHCUpgradeSimulations.Configuration.postLS1Customs import customise_Reco,customise_RawToDigi,customise_DQM if hasattr(process,'RawToDigi'): process=customise_RawToDigi(process) if hasattr(process,'reconstruction'): process=customise_Reco(process) if hasattr(process,'dqmoffline_step'): process=customise_DQM(process) return process
def PileUpJetID(self) : from RecoJets.JetProducers.PileupJetIDParams_cfi import full_53x, full_5x, cutbased from RecoJets.JetProducers.PileupJetID_cfi import pileupJetIdProducer full_53x.tmvaWeights = cms.string("RecoJets/JetProducers/data/TMVAClassificationCategory_JetID_53X_Dec2012.weights.xml") full_53x.label = cms.string("full53x") full_5x.label = cms.string("full5x") JetCollection = "selectionsusycafak5pfjet" + ("Matched0" if not self.options.isData else "0") self.process.puJetId = pileupJetIdProducer.clone( produceJetIds = cms.bool(True), jetids = cms.InputTag(""), runMvas = cms.bool(False), jets = cms.InputTag( JetCollection), vertexes = cms.InputTag("offlinePrimaryVertices"), algos = cms.VPSet(cutbased) ) self.process.puJetMva = pileupJetIdProducer.clone( produceJetIds = cms.bool(False), jetids = cms.InputTag("puJetId"), runMvas = cms.bool(True), jets = cms.InputTag( JetCollection), vertexes = cms.InputTag("offlinePrimaryVertices"), algos = cms.VPSet(full_53x, full_5x) ) return (self.process.puJetId * self.process.puJetMva )
def get(todo): defs = {} # HFRecHits defs["HFRecHitView"] = cms.PSet( miniView = cms.string("HFRecHitView"), branchPrefix = cms.untracked.string("HFRecHit"), ) # HBHERecHits defs["HBHERecHitView"] = cms.PSet( miniView = cms.string("HBHERecHitView"), branchPrefix = cms.untracked.string("HBHERecHit"), ) # EcalRecHits defs["EcalRecHitView"] = cms.PSet( miniView = cms.string("EcalRecHitView"), branchPrefix = cms.untracked.string("EcalRecHit"), ) # main function ret = {} for t in todo: if t not in defs: raise Exception("miniView def not known "+t) ret[t] = defs[t] return ret
def addPoolDBESSource( process, moduleName, record, tag, connect='sqlite_file:', label='',): from CondCore.CondDB.CondDB_cfi import CondDB calibDB = cms.ESSource("PoolDBESSource", CondDB, timetype = cms.string('runnumber'), toGet = cms.VPSet(cms.PSet( record = cms.string(record), tag = cms.string(tag), label = cms.untracked.string(label) )), ) calibDB.connect = cms.string( str(connect) ) #if authPath: calibDB.DBParameters.authenticationPath = authPath if 'oracle:' in connect: calibDB.DBParameters.authenticationPath = '/afs/cern.ch/cms/DB/conddb' setattr(process,moduleName,calibDB) setattr(process,"es_prefer_" + moduleName,cms.ESPrefer('PoolDBESSource', moduleName) )
def makeAnalysisStep(self, stepName, **inputs): step = super(GGHZZKFactors, self).makeAnalysisStep(stepName, **inputs) if stepName == 'initialStateEmbedding': sfFile = path.join(UWVV_BASE_PATH, 'data', 'kFactors', 'Kfactor_Collected_ggHZZ_2l2l_NNLO_NNPDF_NarrowWidth_13TeV.root') ggKEmbedding4e = cms.EDProducer( "GGHZZKFactorEmbedderEEEE", src = step.getObjTag('eeee'), fileName = cms.string(sfFile), ) step.addModule('ggKEmbedding4e', ggKEmbedding4e, 'eeee') ggKEmbedding2e2m = cms.EDProducer( "GGHZZKFactorEmbedderEEMuMu", src = step.getObjTag('eemm'), fileName = cms.string(sfFile), ) step.addModule('ggKEmbedding2e2m', ggKEmbedding2e2m, 'eemm') ggKEmbedding4m = cms.EDProducer( "GGHZZKFactorEmbedderMuMuMuMu", src = step.getObjTag('mmmm'), fileName = cms.string(sfFile), ) step.addModule('ggKEmbedding4m', ggKEmbedding4m, 'mmmm') return step
def CreatePlotEntry(analyzer, discriminatorLabel=None, step=True): """CreatePlotEntry(analyzer, discriminatorLabel)\n Creates a PSet with the informations used by TauDQMHistEffProducer\n where to find the numerator and denominator\n where to put the new plot and how to name it\n which variables control""" producer = analyzer.TauProducer.pythonValue()[1:-1] ext = analyzer.ExtensionName.pythonValue()[1:-1] if discriminatorLabel == None: num = 'RecoTauV/%s%s_Matched/%sMatched_vs_#PAR#TauVisible'%(producer,ext,producer) #out = 'RecoTauV/%s%s_Matched/PFJetMatchingEff#PAR#'%(producer,ext) if producer.find('caloReco') != -1: out = 'RecoTauV/%s%s_Matched/CaloJetMatchingEff#PAR#'%(producer,ext) else: out = 'RecoTauV/%s%s_Matched/PFJetMatchingEff#PAR#'%(producer,ext) else: num = 'RecoTauV/%s%s_%s/%s_vs_#PAR#TauVisible'%(producer,ext,discriminatorLabel,discriminatorLabel) if discriminatorLabel.find('DiscriminationBy') != -1: hname = discriminatorLabel[(discriminatorLabel.find('DiscriminationBy')+len('DiscriminationBy')):] else: hname = discriminatorLabel[(discriminatorLabel.find('Discrimination')+len('Discrimination')):] out = 'RecoTauV/%s%s_%s/%sEff#PAR#'%(producer,ext,discriminatorLabel,hname) den = 'RecoTauV/%s%s_ReferenceCollection/nRef_Taus_vs_#PAR#TauVisible'%(producer,ext) ret = cms.PSet( numerator = cms.string(num), denominator = cms.string(den), efficiency = cms.string(out), parameter = cms.vstring('pt', 'eta', 'phi', 'pileup'), stepByStep = cms.bool(step) ) return ret
def addSusyParticleVariables(pt): if hasattr(pt,"variables"): pt.variables.std_vector_susy_pt = cms.string("susyParticlePt/4") pt.variables.std_vector_susy_eta = cms.string("susyParticleEta/4") pt.variables.std_vector_susy_phi = cms.string("susyParticlePhi/4") pt.variables.std_vector_susy_id = cms.string("susyParticleID/4")
def makeCategoryParams(llWPs=[], diLeptonTriggerMatch=False, addPassAll=False): categs = dict() ## take dilepton working points from input for l1 in ("El", "Mu"): for l2 in ("El", "Mu"): flav = "".join((l1,l2)) base = cms.PSet( NElectrons = cms.uint32(sum( 1 for l in (l1,l2) if l == "El" )) , NMuons = cms.uint32(sum( 1 for l in (l1,l2) if l == "Mu" )) , Category = cms.string("is{0}".format(flav)) , HLT = cms.vstring(dileptonTriggers[flav]) if diLeptonTriggerMatch else cms.vstring() , Cuts = cms.VPSet( cms.PSet(Mll = cms.string("p4.M > 20")) , cms.PSet(ZVeto = cms.string("( p4.M < 76 ) || ( p4.M > 116 )")) ) , WPs=cms.vstring(llWPs) ) categs["{0}OS".format(flav)] = base.clone(Charge=cms.int32( 0), Category=cms.string("is{0} && isOS".format(flav))) categs["{0}Plus".format(flav)] = base.clone(Charge=cms.int32( 1)) categs["{0}Minus".format(flav)] = base.clone(Charge=cms.int32(-1)) if addPassAll: categs["all"] = cms.PSet( NElectrons = cms.uint32(0) , NMuons = cms.uint32(0) , Category = cms.string("") , HLT = cms.vstring() , Cuts = cms.VPSet() , WPs = cms.vstring() , Charge = cms.int32(0) ) return cms.PSet(**categs)
def addPhotonReReco(process, isAOD=False): """Include the photon re-reco sequence in the patDefaultSequence See https://hypernews.cern.ch/HyperNews/CMS/get/egamma/960.html and https://hypernews.cern.ch/HyperNews/CMS/get/egamma/958/1/1/1/1/1/1/1/1/1/1/1.html """ if isAOD: process.photons.barrelEcalHits = cms.InputTag("reducedEcalRecHitsEB") process.photons.endcapEcalHits = cms.InputTag("reducedEcalRecHitsEE") from RecoEgamma.PhotonIdentification.isolationCalculator_cfi \ import isolationSumsCalculator as isc isc.barrelEcalRecHitProducer = cms.string('reducedEcalRecHitsEB') isc.endcapEcalRecHitProducer = cms.string('reducedEcalRecHitsEE') isc.barrelEcalRecHitCollection = cms.InputTag('reducedEcalRecHitsEB') isc.endcapEcalRecHitCollection = cms.InputTag('reducedEcalRecHitsEE') process.photons.isolationSumsCalculatorSet = isc process.photonReReco = cms.Sequence( process.photonSequence * process.photonIDSequence ) else: process.photonReReco = cms.Sequence( process.ckfTracksFromConversions * process.conversionSequence * process.photonSequence * process.photonIDSequence ) # Edit the pat sequence to do the rereco process.patDefaultSequence = cms.Sequence(process.photonReReco* process.patDefaultSequence)
def applyDefaultSelectionsPT(process): #DONT CHANGE THOSE HERE:: THEY ARE NOT USED FOR YOUR SELECTIONS!!! #ONLY FOR SYSTEMATICS . PLEASE CHANGE THEM in YOUR CFG FILE IF REALLY NEEDED process.selectedPatTaus = cms.EDFilter("PATTauSelector", src = cms.InputTag("cleanPatTaus"), cut = cms.string('pt>15&&tauID("byLooseIsolationMVA")&&tauID("againstElectronLoose")&&tauID("againstMuonLoose")'), filter = cms.bool(False) ) process.selectedPatElectrons = cms.EDFilter("PATElectronSelector", src = cms.InputTag("cleanPatElectrons"), cut = cms.string('pt>10&&userFloat("wp95")>0&&(userIso(0)+max(photonIso+neutralHadronIso()-0.5*userIso(2),0.0))/pt()<0.3'), filter = cms.bool(False) ) process.selectedPatMuons = cms.EDFilter("PATMuonSelector", src = cms.InputTag("cleanPatMuons"), cut = cms.string('pt>10&&userInt("tightID")&&(userIso(0)+max(photonIso+neutralHadronIso()-0.5*userIso(2),0.0))/pt()<0.3'), filter = cms.bool(False) ) process.cleanPatJets = cms.EDProducer("PATJetCleaner", src = cms.InputTag("selectedPatJets"), preselection = cms.string('abs(eta)<5.0&&userFloat("idLoose")>0&&pt>10&&userInt("fullIdLoose")>0'), checkOverlaps = cms.PSet(), finalCut = cms.string('') ) process.selectedObjectsForSyst = cms.Sequence(process.selectedPatTaus+process.selectedPatElectrons+process.selectedPatMuons+process.cleanPatJets) process.analysisSequence = cms.Sequence(process.analysisSequence*process.selectedObjectsForSyst)
def addCrossSelector(self, obj, selection, name='', **otherObjects): ''' Add a module to do a string cut and to do delta R cross-cleaning on objects of type obj, and any other object collections. The keyword arguments specify the other collections to clean with respect to, and should be of the form obj:{'selection':'someSelection','deltaR':distance}. So to clean objects that have pt<5 GeV or are within 0.4 of any 30+ GeV slimmed jet, one would call this funtion like: crossSelector('pt > 5.', j={'deltaR':0.4, 'selection':'pt>30','tag':'slimmedJets'}) If 'name' is empty, the module is called <obj>crossCleaning<stepName>. ''' overlapParams = cms.PSet() for obj2, params in otherObjects.iteritems(): objParams = cms.PSet( src=self.getObjTag(obj2), algorithm=cms.string('byDeltaR'), preselection=cms.string(params.get('selection','')), deltaR=cms.double(params.get('deltaR',0.3)), checkRecoComponents=cms.bool(False), pairCut=cms.string(''), requireNoOverlaps=cms.bool(True), ) setattr(overlapParams, getObjName(obj2), objParams) mod = cms.EDProducer( "PAT{}Cleaner".format(getObjName(obj.split('_')[0], True)), src=self.getObjTag(obj), preselection=cms.string(selection), checkOverlaps = overlapParams, finalCut = cms.string(''), ) self.addModule(''.join([obj, name if name else 'crossCleaning', self.name]).replace('_',''), mod, obj)
def addTriggerMatchingForLeptons(process, postfix='') : # define the trigger matchers process.muTriggerMatchPF = cms.EDProducer( "PATTriggerMatcherDRLessByR", src = cms.InputTag( "selectedPatMuons"+postfix ), matched = cms.InputTag( "patTrigger" ), matchedCuts = cms.string( 'type( "TriggerMuon" ) && ( path("HLT_Mu8_*") || path("HLT_Mu12_*") || path("HLT_Mu13_Mu8_*") || path("HLT_DoubleMu7_*" || path("HLT_Mu17_Mu8_*)' ), maxDPtRel = cms.double( 0.5 ), # no effect here maxDeltaR = cms.double( 0.5 ), maxDeltaEta = cms.double( 0.2 ), # no effect here # definition of matcher output resolveAmbiguities = cms.bool( False ), resolveByMatchQuality = cms.bool( False ) ) process.eleTriggerMatchPF = cms.EDProducer( "PATTriggerMatcherDRLessByR", src = cms.InputTag( "selectedPatElectrons"+postfix ), matched = cms.InputTag( "patTrigger" ), #matchedCuts = cms.string( 'type( "TriggerL1NoIsoEG" ) || type( "TriggerL1IsoEG" ) || type( "TriggerElectron" )' ), matchedCuts = cms.string( 'type( "TriggerElectron" )' ), maxDPtRel = cms.double( 0.5 ), # no effect here maxDeltaR = cms.double( 0.5 ), maxDeltaEta = cms.double( 0.2 ), # no effect here # definition of matcher output resolveAmbiguities = cms.bool( False ), resolveByMatchQuality = cms.bool( False ) ) from PhysicsTools.PatAlgos.tools.coreTools import removeCleaning removeCleaning( process ) setattr( process, 'muTriggerMatch' + postfix, process.muTriggerMatchPF ) setattr( process, 'eleTriggerMatch' + postfix, process.eleTriggerMatchPF ) switchOnTriggerMatching( process, triggerMatchers = [ 'muTriggerMatchPFlow','eleTriggerMatchPFlow' ], sequence = 'patPF2PATSequence' + postfix ) removeCleaningFromTriggerMatching( process, sequence = 'patPF2PATSequence' + postfix )
def setCondition(process, connect = "frontier://FrontierProd/CMS_CONDITIONS", record = None, tag = None, label = None): """ Overrides a condition in startgeometry from globaltag. """ if record is None or tag is None: raise ValueError("A 'record' and a 'tag' have to be provided to 'setCondition'.") if not hasattr(process, "GlobalTag"): process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") args = {"connect": cms.string(connect), "record": cms.string(record), "tag": cms.string(tag)} if label is not None: args["label"] = cms.untracked.string(label) process.GlobalTag.toGet \ = cms.VPSet(filter(lambda x: x.record.value() != record, process.GlobalTag.toGet.value())) process.GlobalTag.toGet.append(cms.PSet(**args))
def loadLocalJECDBfile(process, dbfile = '', tag = 'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI', label = 'AK4PFPuppi'): #=================================================== # local BD reader # load and replace the data base by the local one #=================================================== #print ':: dbfile == ', dbfile process.load("CondCore.DBCommon.CondDBCommon_cfi") process.load("CondCore.DBCommon.CondDBSetup_cfi") setattr(process, 'jec' + label, cms.ESSource("PoolDBESSource", DBParameters = cms.PSet( messageLevel = cms.untracked.int32(0) ), timetype = cms.string('runnumber'), toGet = cms.VPSet(cms.PSet( record = cms.string('JetCorrectionsRecord'), tag = cms.string(tag), label = cms.untracked.string(label) )), connect = cms.string('sqlite_file:%s' % dbfile) )) setattr(process, 'es_prefer_jec' + label, cms.ESPrefer('PoolDBESSource','jec'+ label))
def createJERESource(process): datadir = "%s/src/flashgg/Systematics/data/JER" % environ['CMSSW_BASE'] print "WARNING: we are reading JER from %s so GRID jobs might not work" % datadir process.load('Configuration.StandardSequences.Services_cff') process.load("JetMETCorrections.Modules.JetResolutionESProducer_cfi") from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup process.jer = cms.ESSource("PoolDBESSource", CondDBSetup, toGet = cms.VPSet( # Resolution cms.PSet( record = cms.string('JetResolutionRcd'), tag = cms.string('JR_Spring16_25nsV6_MC_PtResolution_AK4PFchs'), label = cms.untracked.string('AK4PFchs_pt') ), # Scale factors cms.PSet( record = cms.string('JetResolutionScaleFactorRcd'), tag = cms.string('JR_Spring16_25nsV6_MC_SF_AK4PFchs'), label = cms.untracked.string('AK4PFchs') ), ), # [2016-02-21 14:50:14,703] INFO: Connecting to Systematics/data/JER/Summer15_25nsV6_MC.db [sqlite:///Systematics/data/JER/Summer15_25nsV6_MC.db] # JR_Summer15_25nsV6_MC_SF_AK4PFchs Run JME::JetResolutionObject any -1 2016-02-05 20:59:34.061327 New Tag # JR_Summer15_25nsV6_MC_PtResolution_AK4PFchs Run JME::JetResolutionObject any -1 2016-02-05 20:59:34.064554 New Tag connect = cms.string('sqlite_file:%s/Spring16_25nsV6_MC.db' % datadir) ) process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')
def customise_csc_cond_ungangedME11A_mc(process): """ Pick up upgrade condions data directly from DB tags using ESPrefer's. Might be useful when dealing with a global tag that doesn't include 'unganged' CSC conditions. """ myconds = [ ('CSCDBGainsRcd', 'CSCDBGains_ungangedME11A_mc'), ('CSCDBNoiseMatrixRcd', 'CSCDBNoiseMatrix_ungangedME11A_mc'), ('CSCDBCrosstalkRcd', 'CSCDBCrosstalk_ungangedME11A_mc'), ('CSCDBPedestalsRcd', 'CSCDBPedestals_ungangedME11A_mc'), ('CSCDBGasGainCorrectionRcd', 'CSCDBGasGainCorrection_ungangedME11A_mc'), ('CSCDBChipSpeedCorrectionRcd', 'CSCDBChipSpeedCorrection_ungangedME11A_mc') ] from CalibMuon.Configuration.getCSCConditions_frontier_cff import cscConditions for (classname, tag) in myconds: print classname, tag sourcename = 'unganged_' + classname process.__setattr__(sourcename, cscConditions.clone()) process.__getattribute__(sourcename).toGet = cms.VPSet( cms.PSet( record = cms.string(classname), tag = cms.string(tag)) ) process.__getattribute__(sourcename).connect = cms.string('frontier://FrontierProd/CMS_COND_CSC_000') process.__setattr__('esp_' + classname, cms.ESPrefer("PoolDBESSource", sourcename) ) del cscConditions return process
def addMuVars( s3 ): vars = {} flags = {} muVars = dict( normalizedChi2 = "? {0}.isGlobalMuon ? {0}.globalTrack.normalizedChi2 : -9999", numberOfValidMuonHits = "? {0}.isGlobalMuon ? {0}.globalTrack.hitPattern.numberOfValidMuonHits : -9999", numberOfMatches = "? {0}.isGlobalMuon ? {0}.numberOfMatches : -9999", TMLastStationTight = "? {0}.isTrackerMuon ? {0}.muonID('TMLastStationTight') : -9999", trkKink = "{0}.combinedQuality.trkKink", trackerLayersWithMeasurement = "{0}.innerTrack.hitPattern.trackerLayersWithMeasurement", numberOfValidPixelHits = "{0}.innerTrack.hitPattern.numberOfValidPixelHits", trackRelErr = "abs({0}.track.ptError / {0}.pt)", # trackRelErr2 = "abs({0}.track.ptError / {0}.track.pt)", ) muFlags = dict( isGlobalMuon = "{0}.isGlobalMuon()", isTrakerMuon = "{0}.isTrackerMuon()", isPFMuon = "{0}.isPFMuon", ) for i in [0,1]: for (name,raw) in muVars.iteritems(): formula = ('? abs({0}.pdgId) == 13 ? '+raw+' : -9999').format('candByPt('+str(i)+')') vars[name+str(i+1)] = cms.string(formula) for (name,raw) in muFlags.iteritems(): formula = ('? abs({0}.pdgId) == 13 ? '+raw+' : -9999').format('candByPt('+str(i)+')') flags[name+str(i+1)] = cms.string(formula) addVarFlags(s3, vars = vars, flags = flags)
def addCategory(pset,label,cutbased=None,subcats=0,variables=[],histograms=[],mvas=None,classname=None,binnedOnly=None, dumpPdfWeights=None,nPdfWeights=None,nAlphaSWeights=None,nScaleWeights=None,splitPdfByStage0Cat=None): if subcats >= 0: catDef = cms.PSet(label=cms.string(label), subcats=cms.int32(subcats), variables=cms.VPSet(), histograms=cms.VPSet(), ) if classname: catDef.className=cms.string(classname) if binnedOnly: catDef.binnedOnly=cms.bool(binnedOnly) if dumpPdfWeights: catDef.dumpPdfWeights=cms.bool(dumpPdfWeights) if nPdfWeights: catDef.nPdfWeights=cms.int32(nPdfWeights) if nAlphaSWeights: catDef.nAlphaSWeights=cms.int32(nAlphaSWeights) if nScaleWeights: catDef.nScaleWeights=cms.int32(nScaleWeights) if splitPdfByStage0Cat is not None: catDef.splitPdfByStage0Cat=cms.bool(splitPdfByStage0Cat) addVariables( catDef.variables, variables ) addHistograms( catDef.histograms, histograms ) if mvas: catDef.mvas = cms.VPSet() addMVAs( catDef.mvas, mvas ) pset.categories.append(catDef) if cutbased: cb = cms.PSet( cut=cms.string(cutbased) ) if( label != "" or classname): cb.name = cms.untracked.string(label) pset.classifierCfg.categories.append(cb)
def ecal_complete_aging_3000(process): process=ecal_complete_aging(process) if not hasattr(process.GlobalTag,'toGet'): process.GlobalTag.toGet=cms.VPSet() process.GlobalTag.toGet.extend( cms.VPSet( cms.PSet(record = cms.string("EcalPedestalsRcd"), tag = cms.string("EcalPedestals_TL3000_IL5E34_mc"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL") ), ## laser D cms.PSet(record = cms.string("EcalLaserAPDPNRatiosRcd"), tag = cms.string("EcalLaserAPDPNRatios_TL3000_IL5E34_v2_mc"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL") ), ## L1 trigger cms.PSet(record = cms.string("EcalTPGLinearizationConstRcd"), tag = cms.string("EcalTPGLinearizationConst_TL3000_IL5E34_v2_mc"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL") ), cms.PSet(record = cms.string('EcalLaserAlphasRcd'), tag = cms.string('EcalLaserAlphas_EB_sic1_btcp1_EE_sic1_btcp1'), connect = cms.untracked.string('frontier://FrontierPrep/CMS_COND_ECAL') ), #VPT aging cms.PSet(record = cms.string('EcalLinearCorrectionsRcd'), tag = cms.string('EcalLinearCorrections_mc'), connect = cms.untracked.string('frontier://FrontierPrep/CMS_COND_ECAL') ) ) ) return process
def addMuonJetSelection(process, sequence, prefix="muonSelectionJetSelection"): selector = prefix+"GoodJets" filter = prefix+"Filter" counter = prefix import muonSelectionPF_cff as muonSelection from PhysicsTools.PatAlgos.cleaningLayer1.jetCleaner_cfi import cleanPatJets m1 = cleanPatJets.clone( # src = "selectedPatJets", src = "goodJets", # we should use the pat::Jets constructed in the preselection = cms.string(jetSelection), checkOverlaps = cms.PSet( muons = cms.PSet( src = cms.InputTag(tauEmbeddingMuons), algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True), ) ) ) m2 = muonSelection.goodJetFilter.clone(src=selector, minNumber=3) m3 = cms.EDProducer("EventCountProducer") setattr(process, selector, m1) setattr(process, filter, m2) setattr(process, counter, m3) sequence *= (m1 * m2 * m3) return [counter]
def reduce(self, sort): # reduce can be MEAN or COUNT. in STAGE2, just pass through. # in STAGE1, MEAN (anywhere) means make a PROFILE # COUNT can mean per-event counting or a occupancy plot, which is acheived # by ignoring the values passed to fill() (like dimensions=0, TODO). if self._state == FIRST: if sort != "COUNT": raise Exception("First statement must be groupBy.") self.spec[0].type = COUNT # this is actually a noop # groupBy already saw the "Event" column and set up counting. return self if self._state == STAGE1: if sort == "MEAN": self.spec.append(cms.PSet( type = PROFILE, stage = STAGE1, columns = cms.vstring(), arg = cms.string(""), nbins = cms.int32(-1), xmin = cms.int32(0), xmax = cms.int32(0) )) return self if sort != "MEAN": raise Exception("Harvesting allows only reduce(MEAN) at the moment, not " + sort) self.spec.append(cms.PSet( type = REDUCE, stage = self._state, columns = cms.vstring(), arg = cms.string(sort), nbins = cms.int32(-1), xmin = cms.int32(0), xmax = cms.int32(0) )) return self
def addVariable(vpset,expr,name=None,nbins=None,vmin=None,vmax=None): if ":=" in expr: toks=[ v.rstrip(" ").lstrip(" ") for v in expr.split(":=") ] ## print toks name,expr=toks if not name: name = expr.replace(".","_").replace("get","") if name.endswith("]"): name,rng = name.replace("]","").split("[") rng = rng.split(",") nbins = int(rng[0]) vmin = float(rng[1]) vmax = float(rng[2]) if "map(" in expr: var, bins, vals = expr.lstrip("map(").rstrip(")").split("::") bins = [ float(b) for b in bins.split(",") ] vals = [ float(v) for v in vals.split(",") ] pset = cms.PSet( expr = cms.PSet( var = cms.string(var), bins = cms.vdouble(bins), vals = cms.vdouble(vals) ), name = cms.untracked.string(name), ) else: pset = cms.PSet( expr = cms.string(expr), name = cms.untracked.string(name), ) if nbins: pset.nbins = cms.untracked.int32(nbins) pset.vmin = cms.untracked.double(vmin) pset.vmax = cms.untracked.double(vmax) vpset.append(pset)
def get(todo): defs = {} # ZeroBias trigger configuration defs["ZeroBiasTriggerResultsView"] = cms.PSet( miniView = cms.string("TriggerResultsView"), branchPrefix = cms.untracked.string("trg"), process = cms.string("HLT"), triggers = cms.vstring("ZeroBias"), ZeroBias = cms.vstring("HLT_ZeroBias_part*") ) defs["L1GTriggerResultsView"] = cms.PSet( miniView = cms.string("TriggerResultsView"), branchPrefix = cms.untracked.string("trgl1"), process = cms.string("HLT"), triggers = cms.vstring("L1GTTech","L1GTAlgo") ) # main function ret = {} for t in todo: if t not in defs: raise Exception("miniView def not known "+t) ret[t] = defs[t] return ret
def addZMassHistos(self): from PhysicsTools.PatAlgos.cleaningLayer1.muonCleaner_cfi import cleanPatMuons zMassMuons = self.analysis.addAnalysisModule( "ZMassMuons", selector = cleanPatMuons.clone( #preselection = cms.string(zMassVetoMuons), src = muons, checkOverlaps = cms.PSet( muons = cms.PSet( src = self.selectedMuons, algorithm = cms.string("byDeltaR"), preselection = cms.string(""), deltaR = cms.double(0.1), checkRecoComponents = cms.bool(False), pairCut = cms.string(""), requireNoOverlaps = cms.bool(True) ) ) ), counter=False).getSelectorInputTag() self.zmumu = self.analysis.addProducer("ZMuMu", self.candCombinerPrototype.clone(decay = cms.string(self.selectedMuons.getModuleLabel()+" "+zMassMuons.getModuleLabel()))) self.cloneHistoAnalyzer("ZMuMuCands") self.histoAnalyzer.zmumu_ = cms.untracked.PSet(src = self.zmumu, histograms = cms.VPSet(histoZMass.pset())) self.cloneMultipAnalyzer(name="MultiplicityZMuMuCands") self.multipAnalyzer.zMassMuons = self.multipAnalyzer.selMuons.clone(src = zMassMuons)
def load_jec_from_db(process, db, algorithmes): """ Inform CMSSW to read the JEC from a database instead of the GT for the given list of algorithmes """ import os if not os.path.isfile(db): raise ValueError('Database %r does not exist.' % db) if os.path.isabs(db): raise ValueError('You cannot use an absolute for the database, as it breaks crab submission. Please put the database in the same folder as your python configuration file and pass only the filename as argument of the create function') process.load("CondCore.DBCommon.CondDBCommon_cfi") if verbosity: print("Using database %r for JECs\n" % db) process.jec = cms.ESSource("PoolDBESSource", DBParameters = cms.PSet( messageLevel = cms.untracked.int32(0) ), timetype = cms.string('runnumber'), toGet = cms.VPSet(), connect = cms.string('sqlite:%s' % db) ) process.gridin.input_files += [os.path.abspath(db)] process.es_prefer_jec = cms.ESPrefer('PoolDBESSource', 'jec') prefix = os.path.splitext(db)[0] for algo in algorithmes: append_jec_to_db_(process, algo, prefix)
def ageEcal(process,lumi,instLumi): if hasattr(process,'g4SimHits'): #these lines need to be further activiated by tuning on 'complete' aging for ecal process.g4SimHits.ECalSD.InstLuminosity = cms.double(instLumi) process.g4SimHits.ECalSD.DelivLuminosity = cms.double(float(lumi)) # available conditions ecal_lumis = [300,1000,3000,4500] ecal_conditions = [ ['EcalIntercalibConstantsRcd','EcalIntercalibConstants_TL{:d}_upgrade_8deg_mc'], ['EcalIntercalibConstantsMCRcd','EcalIntercalibConstantsMC_TL{:d}_upgrade_8deg_mc'], ['EcalLaserAPDPNRatiosRcd','EcalLaserAPDPNRatios_TL{:d}_upgrade_8deg_mc'], ['EcalPedestalsRcd','EcalPedestals_TL{:d}_upgradeTIA_8deg_mc'], ['EcalTPGLinearizationConstRcd','EcalTPGLinearizationConst_TL{:d}_upgrade_8deg_mc'], ] # try to get conditions if int(lumi) in ecal_lumis: if not hasattr(process.GlobalTag,'toGet'): process.GlobalTag.toGet=cms.VPSet() for ecal_condition in ecal_conditions: process.GlobalTag.toGet.append(cms.PSet( record = cms.string(ecal_condition[0]), tag = cms.string(ecal_condition[1].format(int(lumi))), connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") ) ) return process
def customiseForQuadrupletsByPropagation(process): for module in process._Process__producers.values(): if not hasattr(module, "SeedMergerPSet"): continue # Adjust seeding layers seedingLayersName = module.OrderedHitsFactoryPSet.SeedingLayers.getModuleLabel() seedingLayersModule = getattr(process, seedingLayersName) seedingLayersModule.layerList = process.PixelSeedMergerQuadruplets.layerList.value() # Configure seed generator / pixel track producer del module.SeedMergerPSet triplets = module.OrderedHitsFactoryPSet.clone() module.OrderedHitsFactoryPSet = cms.PSet( ComponentName = cms.string("CombinedHitQuadrupletGenerator"), GeneratorPSet = cms.PSet( ComponentName = cms.string("PixelQuadrupletGenerator"), extraHitRZtolerance = triplets.GeneratorPSet.extraHitRZtolerance, extraHitRPhitolerance = triplets.GeneratorPSet.extraHitRPhitolerance, maxChi2 = cms.double(50), keepTriplets = cms.bool(True) ), TripletGeneratorPSet = triplets.GeneratorPSet, SeedingLayers = cms.InputTag(seedingLayersName), ) if hasattr(triplets.GeneratorPSet, "SeedComparitorPSet"): module.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = triplets.GeneratorPSet.SeedComparitorPSet if module.type_() == "PixelTrackProducer": module.CleanerPSet.useQuadrupletAlgo = cms.bool(True) return process
AddAntiParticle=cms.bool(False)) process.o1 = cms.OutputModule("PoolOutputModule", process.FEVTSIMEventContent, fileName=cms.untracked.string('simevent.root')) process.Timing = cms.Service("Timing") process.Tracer = cms.Service("Tracer") process.p1 = cms.Path(process.generator * process.VtxSmeared * process.g4SimHits) process.outpath = cms.EndPath(process.o1) process.TFileService = cms.Service( "TFileService", fileName=cms.string('PionHcalTestAnalysis.root')) process.g4SimHits.Physics.type = 'SimG4Core/Physics/QGSP_BERT_EML' process.g4SimHits.G4Commands = ['/tracking/verbose 1'] process.common_maximum_timex = cms.PSet( MaxTrackTime=cms.double(1000.0), MaxTimeNames=cms.vstring(), MaxTrackTimes=cms.vdouble(), DeadRegions=cms.vstring(), CriticalEnergyForVacuum=cms.double(2.0), CriticalDensity=cms.double(1e-15)) process.g4SimHits.StackingAction = cms.PSet( process.common_heavy_suppression, process.common_maximum_timex, TrackNeutrino=cms.bool(False), KillDeltaRay=cms.bool(False),
process.EnableFloatingPointExceptions = cms.Service("EnableFloatingPointExceptions") process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService", generator = cms.PSet( initialSeed = cms.untracked.uint32(123456789), engineName = cms.untracked.string('HepJamesRandom') ), VtxSmeared = cms.PSet( engineName = cms.untracked.string('HepJamesRandom'), initialSeed = cms.untracked.uint32(98765432) ), g4SimHits = cms.PSet( initialSeed = cms.untracked.uint32(11), engineName = cms.untracked.string('HepJamesRandom') ) ) process.load('SimG4Core.Application.g4SimHits_cfi') process.p1 = cms.Path(process.generator*process.VtxSmeared*process.generatorSmeared*process.g4SimHits) process.g4SimHits.Physics.type = 'SimG4Core/Physics/DummyPhysics' process.g4SimHits.UseMagneticField = False process.g4SimHits.Physics.DummyEMPhysics = True process.g4SimHits.Physics.DefaultCutValue = 10. process.g4SimHits.Watchers = cms.VPSet(cms.PSet( Name = cms.untracked.string('TIDF'), type = cms.string('PrintMaterialBudgetInfo') ))
"topPairEPlusJetsSelection", 'TopPairElectronPlusJetsSelection.signalElectron', 'PAT'), muon_input=cms.InputTag("topPairMuPlusJetsSelection", 'TopPairMuonPlusJetsSelection.signalMuon', 'PAT'), vertex_input=cms.InputTag('goodOfflinePrimaryVertices'), gen_event_input=cms.InputTag('genEvt'), selection_flag_input=cms.InputTag( "topPairEPlusJetsSelection", 'TopPairElectronPlusJetsSelection.FullSelection', 'PAT'), is_fully_hadronic_flag=cms.InputTag('ttFullHadronicFilter'), is_dileptonic_flag=cms.InputTag('ttFullLeptonicFilter'), is_semileptonic_tau_flag=cms.InputTag('ttSemiLeptonicTauFilter'), is_semileptonic_electron_flag=cms.InputTag('ttSemiLeptonicElectronFilter'), is_semileptonic_muon_flag=cms.InputTag('ttSemiLeptonicMuonFilter'), do_electron_channel=cms.untracked.bool(True), variable_under_analysis=cms.string('MET'), variable_min=cms.double(variable_bins['MET']['min']), variable_max=cms.double(variable_bins['MET']['max']), variable_n_bins=cms.uint32(variable_bins['MET']['n_bins']), bin_edges=cms.vdouble([0, 25, 45, 70, 100, 150, 2000]), centre_of_mass_energy=cms.double(8), ) unfolding_MET_analyser_muon_channel_patMETsPFlow = unfolding_MET_analyser_electron_channel_patMETsPFlow.clone( do_electron_channel=cms.untracked.bool(False), ) unfolding_MET_nu_analyser_electron_channel_patMETsPFlow = unfolding_MET_analyser_electron_channel_patMETsPFlow.clone( variable_under_analysis=cms.string('MET_nu'), ) unfolding_MET_nu_analyser_muon_channel_patMETsPFlow = unfolding_MET_nu_analyser_electron_channel_patMETsPFlow.clone( do_electron_channel=cms.untracked.bool(False), )
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.GenJetParameters_cfi import * from RecoJets.JetProducers.AnomalousCellParameters_cfi import * iterativeCone5GenJets = cms.EDProducer( "FastjetJetProducer", GenJetParameters, AnomalousCellParameters, jetAlgorithm=cms.string("IterativeCone"), rParam=cms.double(0.5))
from Configuration.Eras.Modifier_fastSim_cff import fastSim # NEW CLUSTERS (remove previously used clusters) pixelPairStepClusters = _cfg.clusterRemoverForIter("PixelPairStep") for _eraName, _postfix, _era in _cfg.nonDefaultEras(): _era.toReplaceWith(pixelPairStepClusters, _cfg.clusterRemoverForIter("PixelPairStep", _eraName, _postfix)) # SEEDING LAYERS pixelPairStepSeedLayers = cms.EDProducer("SeedingLayersEDProducer", layerList = cms.vstring('BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3', 'BPix1+FPix1_pos', 'BPix1+FPix1_neg', 'BPix2+FPix1_pos', 'BPix2+FPix1_neg', 'FPix1_pos+FPix2_pos', 'FPix1_neg+FPix2_neg'), BPix = cms.PSet( TTRHBuilder = cms.string('WithTrackAngle'), HitProducer = cms.string('siPixelRecHits'), skipClusters = cms.InputTag('pixelPairStepClusters') ), FPix = cms.PSet( TTRHBuilder = cms.string('WithTrackAngle'), HitProducer = cms.string('siPixelRecHits'), skipClusters = cms.InputTag('pixelPairStepClusters') ) ) # layers covering the region not covered by quadruplets (so it is # just acting as backup of triplets) _layerListForPhase1 = [ 'BPix1+BPix2', 'BPix1+BPix3', 'BPix2+BPix3', 'BPix1+FPix1_pos', 'BPix1+FPix1_neg', 'BPix2+FPix1_pos', 'BPix2+FPix1_neg',
process.load('Configuration.StandardSequences.GeometryDB_cff') process.load('Configuration.StandardSequences.MagneticField_38T_cff') process.load('Configuration.StandardSequences.ReconstructionHeavyIons_cff') process.load('Configuration.StandardSequences.EndOfProcess_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.load('Appeltel.HIRun2015Ana.HITrackProfiler_cfi') process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1) ) process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True)) process.TFileService = cms.Service("TFileService", fileName = cms.string('trackProfiler.root') ) process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") process.tpRecoAssocGeneralTracks = process.trackingParticleRecoTrackAsssociation.clone() process.tpRecoAssocGeneralTracks.label_tr = cms.InputTag("TrackRefitter") process.load("SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi") process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') process.quickTrackAssociatorByHits.Cut_RecoToSim = 0.02 process.quickTrackAssociatorByHits.Quality_SimToReco = 0.02 process.quickTrackAssociatorByHits.Purity_SimToReco = 0.02 process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi")
process.DiMuFilter= cms.EDFilter("DiMuonFilter", vertex=cms.InputTag("offlineSlimmedPrimaryVertices"), muonSrc =cms.InputTag("slimmedMuons"), bits = cms.InputTag("TriggerResults","","HLT"), objects = cms.InputTag("slimmedPatTrigger"), trigNames = cms.vstring("HLT_IsoMu27_v","HLT_IsoTkMu27_v","HLT_IsoMu24_v","HLT_IsoTkMu24_v"), ) ################################################################################################# process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) process.TFileService = cms.Service("TFileService", fileName = cms.string('file:TauEfficiency_MuonAllID_mA20_OldTauID.root') ) process.p_l = cms.Path(process.GenModeFilterMu*process.DiMuFilter*process.ThirdMuFilter*process.MuEffLoose*process.TauEffDModeLoose*process.TauEffMDModeLoose); process.p_m = cms.Path(process.GenModeFilterMu*process.DiMuFilter*process.ThirdMuFilterMedium*process.MuEffMedium*process.TauEffDModeMedium*process.TauEffMDModeMedium); process.p_t = cms.Path(process.GenModeFilterMu*process.DiMuFilter*process.ThirdMuFilterTight*process.MuEffTight*process.TauEffDModeTight*process.TauEffMDModeTight); process.schedule=cms.Schedule(process.p_l,process.p_m,process.p_t)
import FWCore.ParameterSet.Config as cms slimmedMuons = cms.EDProducer( "PATMuonSlimmer", src=cms.InputTag("selectedPatMuons"), linkToPackedPFCandidates=cms.bool(True), pfCandidates=cms.VInputTag(cms.InputTag("particleFlow")), packedPFCandidates=cms.VInputTag(cms.InputTag("packedPFCandidates")), saveTeVMuons=cms.string( "pt > 100"), # you can put a cut to slim selectively, e.g. pt > 10 dropDirectionalIso=cms.string("0"), dropPfP4=cms.string("1"), slimCaloVars=cms.string("1"), slimKinkVars=cms.string("1"), slimCaloMETCorr=cms.string("1"), slimMatches=cms.string("1"), segmentsMuonSelection=cms.string( "pt > 50" ), #segments are needed for EXO analysis looking at TOF and for very high pt from e.g. Z' saveSegments=cms.bool(True), modifyMuons=cms.bool(True), modifierConfig=cms.PSet(modifications=cms.VPSet()))
import FWCore.ParameterSet.Config as cms process = cms.Process("DQM") # DQM service process.load("DQMServices.Core.DQMStore_cfi") # MessageLogger process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 # Global Tag from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag as customiseGlobalTag process.GlobalTag = customiseGlobalTag(globaltag='80X_dataRun2_HLT_v12') process.GlobalTag.connect = cms.string( 'frontier://FrontierProd/CMS_CONDITIONS') # Source process.source = cms.Source( "PoolSource", fileNames=cms.untracked.vstring( '/store/data/Run2016B/HLTPhysics2/RAW/v1/000/272/022/00000/4CE23DEB-CB0D-E611-A6AC-02163E01181C.root' )) process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1000)) # unpack L1 digis process.load("EventFilter.L1TRawToDigi.gtStage2Digis_cfi") process.gtStage2Digis.InputLabel = cms.InputTag("rawDataCollector") process.load("DQM.HLTEvF.triggerBxMonitor_cfi") process.triggerBxMonitor.l1tResults = cms.untracked.InputTag('gtStage2Digis')
import FWCore.ParameterSet.Config as cms # link to cards: # https://github.com/cms-sw/genproductions/tree/afad53082a334f6e6ad4a3769124ccc50b8e8991/bin/MadGraph5_aMCatNLO/cards/production/13TeV/exo_diboson/Spin-1/Wprime_Wh_Whadhtata/Wprime_Wh_Whadhtata_narrow_M1400 externalLHEProducer = cms.EDProducer( "ExternalLHEProducer", args=cms.vstring( '/cvmfs/cms.cern.ch/phys_generator/gridpacks/slc6_amd64_gcc481/13TeV/madgraph/V5_2.2.2/exo_diboson/Spin-1/Wprime_Wh_Whadhtata/narrow/v1/Wprime_Wh_Whadhtata_narrow_M1400_tarball.tar.xz' ), nEvents=cms.untracked.uint32(5000), numberOfParameters=cms.uint32(1), outputFile=cms.string('cmsgrid_final.lhe'), scriptName=cms.FileInPath( 'GeneratorInterface/LHEInterface/data/run_generic_tarball_cvmfs.sh'))
initL1O2OTagsExt() if options.keysFromDB == 1: process.load("CondTools.L1TriggerExt.L1ConfigRSKeysExt_cff") else: process.load("CondTools.L1TriggerExt.L1TriggerKeyDummyExt_cff") from CondTools.L1TriggerExt.L1RSSubsystemParamsExt_cfi import initL1RSSubsystemsExt initL1RSSubsystemsExt( tagBaseVec = initL1O2OTagsExt.tagBaseVec ) process.L1TriggerKeyDummyExt.objectKeys = initL1RSSubsystemsExt.params.recordInfo # Get L1TriggerKeyListExt from DB process.load("CondCore.DBCommon.CondDBCommon_cfi") process.outputDB = cms.ESSource("PoolDBESSource", process.CondDBCommon, toGet = cms.VPSet(cms.PSet( record = cms.string('L1TriggerKeyListExtRcd'), tag = cms.string('L1TriggerKeyListExt_' + initL1O2OTagsExt.tagBaseVec[ L1CondEnumExt.L1TriggerKeyListExt ] ) )) ) process.outputDB.connect = options.outputDBConnect process.outputDB.DBParameters.authenticationPath = options.outputDBAuth # writer modules from CondTools.L1TriggerExt.L1CondDBIOVWriterExt_cff import initIOVWriterExt initIOVWriterExt( process, outputDBConnect = options.outputDBConnect, outputDBAuth = options.outputDBAuth, tagBaseVec = initL1O2OTagsExt.tagBaseVec, tscKey = '' ) process.L1CondDBIOVWriterExt.logKeys = True
process = cms.Process("RECO2") process.load('Configuration.StandardSequences.Services_cff') process.load('FWCore.MessageService.MessageLogger_cfi') process.load('Configuration.EventContent.EventContent_cff') process.load('Configuration.StandardSequences.GeometryRecoDB_cff') process.load('Configuration.Geometry.GeometrySimDB_cff') process.load('Configuration.StandardSequences.MagneticField_38T_PostLS1_cff') process.load('Configuration.StandardSequences.EndOfProcess_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.load('Configuration.StandardSequences.RawToDigi_cff') process.load('Configuration.StandardSequences.Reconstruction_cff') process.GlobalTag.globaltag = 'POSTLS172_V1::All' process.GlobalTag.toGet = cms.VPSet( cms.PSet(record = cms.string("GeometryFileRcd"), tag = cms.string("XMLFILE_Geometry_2015_72YV2_Extended2015ZeroMaterial_mc"), connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_GEOMETRY_000"), # label = cms.untracked.string("Extended2015ZeroMaterial") ), cms.PSet(record = cms.string("EcalTBWeightsRcd"), tag = cms.string("EcalTBWeights_3p5_time_mc"), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_ECAL") ) ) #### CONFIGURE IT HERE isMC = True ##################### process.MessageLogger.cerr.FwkReport.reportEvery = 1
import FWCore.ParameterSet.Config as cms process = cms.Process("ANALYSIS") process.load("Configuration.StandardSequences.Services_cff") process.load("Configuration.StandardSequences.Reconstruction_cff") process.load("Configuration.StandardSequences.RawToDigi_Data_cff") process.load( "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") process.GlobalTag.globaltag = cms.string('GR09_P_V8_34X::All') process.load("Configuration.StandardSequences.Geometry_cff") process.load("Configuration.StandardSequences.MagneticField_cff") #process.load("FWCore.MessageLogger.MessageLogger_cfi") process.load("DQM.SiStripCommon.MessageLogger_cfi") process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1)) process.source = cms.Source( "PoolSource", fileNames=cms.untracked.vstring( #'/store/data/BeamCommissioning09/MinimumBias/RECO/v2/000/124/009/A81DC948-A2E6-DE11-AF25-000423D94524.root', '/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0100/965030FF-3DE9-DE11-B75B-00151796C18C.root', '/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0100/485EDF6C-48E9-DE11-BE46-0024E876841F.root', '/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0100/3EAFDE66-71E9-DE11-B861-0024E876A814.root', '/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0099/A683E072-22E9-DE11-B396-001D0967DA6C.root', '/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0099/5E275AD5-35E9-DE11-96BA-00151796D884.root', '/store/data/BeamCommissioning09/MinimumBias/RECO/Dec14thReReco_v1/0099/04E1641C-2AE9-DE11-A073-001D0967CFCC.root' ), #skipEvents = cms.untracked.uint32(0) #eventsToProcess = cms.untracked.VEventRange('124009:10872958-124009:10872958') eventsToProcess=cms.untracked.VEventRange('124120:542515-124120:542515'))
muons = cms.InputTag("slimmedMuons"), electrons = cms.InputTag("slimmedElectrons"), taus = cms.InputTag("slimmedTaus"), photons = cms.InputTag("slimmedPhotons"), jets = cms.InputTag("slimmedJets"), fatjets = cms.InputTag("slimmedJetsAK8"), mets = cms.InputTag("slimmedMETs"), pfCands = cms.InputTag("packedPFCandidates"), packed = cms.InputTag("packedGenParticles"), pruned = cms.InputTag("prunedGenParticles"), bits = cms.InputTag("TriggerResults","","HLT"), prescales = cms.InputTag("patTrigger") ) process.TFileService = cms.Service("TFileService", fileName = cms.string("ttbar407.root"), closeFileFast = cms.untracked.bool(True) ) ############################################### # RECO AND GEN SETUP process.load('PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff') process.load('Configuration.EventContent.EventContent_cff') process.load('Configuration.StandardSequences.Geometry_cff') process.load('Configuration.StandardSequences.MagneticField_38T_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag ='PHYS14_25_V2' #'START70_V6::All' #'START70_V6::All' process.load('RecoJets.Configuration.RecoPFJets_cff')
if chsorpuppi: process.goodAK4Jets.src = "slimmedJets" else: process.goodAK4Jets.src = "slimmedJetsPuppi" #process.goodOfflinePrimaryVertex = cms.EDFilter("VertexSelector", # src = cms.InputTag("offlineSlimmedPrimaryVertices"), # cut = cms.string("chi2!=0 && ndof >= 4.0 && abs(z) <= 24.0 && abs(position.Rho) <= 2.0"), # filter = cms.bool(False) # ) ZBOSONCUT = "pt > 0.0" process.leptonicVSelector = cms.EDFilter("CandViewSelector", src=cms.InputTag("leptonicV"), cut=cms.string(ZBOSONCUT), filter=cms.bool(False)) process.leptonicVFilter = cms.EDFilter("CandViewCountFilter", src=cms.InputTag("leptonicV"), minNumber=cms.uint32(0), filter=cms.bool(False)) process.leptonSequence = cms.Sequence(process.muSequence + process.eleSequence + process.leptonicVSequence + process.leptonicVSelector + process.leptonicVFilter) process.jetSequence = cms.Sequence(process.NJetsSequence)
from cp3_llbb.Framework import METProducer from cp3_llbb.Framework.CmdLine import CmdLine options = CmdLine() runOnData = options.runOnData == 1 globalTag_ = '80X_mcRun2_asymptotic_2016_TrancheIV_v8' processName_ = 'PAT' if runOnData : globalTag_ = '80X_dataRun2_2016SeptRepro_v7' processName_ = 'RECO' framework = Framework.Framework(runOnData, eras.Run2_25ns, globalTag=globalTag_, processName=processName_) framework.addAnalyzer('hh_analyzer', cms.PSet( type = cms.string('hh_analyzer'), prefix = cms.string('hh_'), enable = cms.bool(True), categories_parameters = cms.PSet( # Per-category lepton pt cuts mumu_leadingLeptonPtCut = cms.untracked.double(20), # muon mumu_subleadingLeptonPtCut = cms.untracked.double(10), # muon elel_leadingLeptonPtCut = cms.untracked.double(25), # electron elel_subleadingLeptonPtCut = cms.untracked.double(15), # electron muel_leadingLeptonPtCut = cms.untracked.double(25), # muon muel_subleadingLeptonPtCut = cms.untracked.double(15), # electron elmu_leadingLeptonPtCut = cms.untracked.double(25), # electron elmu_subleadingLeptonPtCut = cms.untracked.double(10), # muon ), parameters = cms.PSet( # Producers
import FWCore.ParameterSet.Config as cms from CondCore.DBCommon.CondDBSetup_cfi import * RerecoGlobalTag = cms.ESSource("PoolDBESSource", CondDBSetup, connect = cms.string('frontier://FrontierProd/CMS_COND_31X_GLOBALTAG'), # globaltag = cms.string('UNSPECIFIED::All'), globaltag = cms.string('GR_R_42_V24::All'), #toGet = cms.VPSet( ), # hook to override or add single payloads toGet = cms.VPSet( cms.PSet(record = cms.string("EcalIntercalibConstantsRcd"), tag = cms.string("EcalIntercalibConstants_2011_V1"), connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_31X_ECAL") ), # ,cms.PSet(record = cms.string("EcalADCToGeVConstantRcd"), # tag = cms.string("EcalADCToGeVConstant_v10_offline"), # connect = cms.untracked.string("frontier://FrontierProd/CMS_COND_31X_ECAL") # ) # , cms.PSet(record = cms.string("EcalLaserAPDPNRatiosRcd"), tag = cms.string("EcalLaserAPDPNRatios_data_20120131_158851_183320"), connect = cms.untracked.string("frontier://FrontierInt/CMS_COND_ECAL") ), # cms.PSet(record = cms.string('EcalLaserAlphasRcd'), tag = cms.string('EcalLaserAlphas_eflow_EBperchan_EEperchanDelta'), connect = cms.untracked.string('frontier://FrontierInt/CMS_COND_ECAL') ) ), BlobStreamerName = cms.untracked.string('TBufferBlobStreamingService')
''' import FWCore.ParameterSet.Config as cms import os # rootfile_dir = os.environ['CMSSW_BASE'] + '/src/CMGTools/H2TauTau/data/metRecoilCorrection/' rootfile_dir = os.environ['CMSSW_BASE'] + '/src/CMGTools/Utilities/data/metRecoilCorrection/' recoilCorrectedMETDiTau2012 = cms.EDProducer( "RecoilCorrectedMETProducer2012DiTau", metSrc = cms.InputTag('cmgPFMET'), # the tau is on the first leg and the muon on the second leg recBosonSrc = cms.InputTag('cmgDiTauSel'), genBosonSrc = cms.InputTag('genWorZ'), jetSrc = cms.InputTag('cmgPFJetForRecoil'), # 1: lepton is on leg1; 2: lepton is on leg2; # 0: take both legs as leptons, and sum them up leptonLeg = cms.int32(0), # 1: type 1; 2 : type 2; 0 : all (use 1) correctionType = cms.int32(2), #fileCorrectTo = cms.string(rootfile_dir + 'recoilfit_htt53X_20pv_njet.root'), fileCorrectTo = cms.string(rootfile_dir + 'recoilfit_ztt53X_20pv_njet.root'), # you should not have to change the files below fileZmmData = cms.string(rootfile_dir + 'recoilfit_datamm53X_20pv_njet.root'), fileZmmMC = cms.string(rootfile_dir + 'recoilfit_zmm53X_20pv_njet.root'), enable = cms.bool(True), force = cms.bool(False), verbose = cms.untracked.bool( False ) #COLIN: make delta R a parameter )
'JetMatching:nQmatch = 5', #4 corresponds to 4-flavour scheme (no matching of b-quarks), 5 for 5-flavour scheme 'JetMatching:nJetMax = 2', #number of partons in born matrix element for highest multiplicity 'JetMatching:doShowerKt = off', #off for MLM matching, turn on for shower-kT matching '6:m0 = 172.5', 'Check:abortIfVeto = on', 'ResonanceDecayFilter:filter = on', 'ResonanceDecayFilter:exclusive = off', #off: require at least the specified number of daughters, on: require exactly the specified number of daughters 'ResonanceDecayFilter:eMuAsEquivalent = off', #on: treat electrons and muons as equivalent 'ResonanceDecayFilter:eMuTauAsEquivalent = on', #on: treat electrons, muons , and taus as equivalent 'ResonanceDecayFilter:allNuAsEquivalent = on', #on: treat all three neutrino flavours as equivalent #'ResonanceDecayFilter:mothers =', #list of mothers not specified -> count all particles in hard process+resonance decays (better to avoid specifying mothers when including leptons from the lhe in counting, since intermediate resonances are not gauranteed to appear in general 'ResonanceDecayFilter:daughters = 11', # '23:mMin = 0.1', '24:mMin = 0.1', ), parameterSets = cms.vstring('pythia8CommonSettings', 'pythia8CUEP8M1Settings', 'JetMatchingParameters' ) ) generator.RandomizedParameters.append( cms.PSet( ConfigWeight = cms.double(wgt), GridpackPath = cms.string('/cvmfs/cms.cern.ch/phys_generator/gridpacks/slc6_amd64_gcc481/13TeV/madgraph/V5_2.3.3/sus_sms/SMS-SqSq/SMS-SqSq_mSq-%i_tarball.tar.xz' % msq), ConfigDescription = cms.string('%s_%i_%i' % (model, msq, mlsp)), SLHATableForPythia8 = cms.string('%s' % slhatable), PythiaParameters = basePythiaParameters, ), )
#process.load("Configuration.Geometry.GeometryIdeal_cff" ) process.load("Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff" ) process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff') from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag #process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_data', '') process.GlobalTag = GlobalTag(process.GlobalTag, '76X_dataRun2_16Dec2015_v0') #process.Tracer = cms.Service("Tracer") process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100000) ) process.MessageLogger.cerr.FwkReport.reportEvery = 1000 #jec from sqlite process.load("CondCore.DBCommon.CondDBCommon_cfi") from CondCore.DBCommon.CondDBSetup_cfi import * process.jec = cms.ESSource("PoolDBESSource",CondDBSetup, connect = cms.string('sqlite:Fall15_25nsV2_DATA.db'), toGet = cms.VPSet( cms.PSet( record = cms.string('JetCorrectionsRecord'), tag = cms.string('JetCorrectorParametersCollection_Fall15_25nsV2_DATA_AK4PFchs'), label = cms.untracked.string('AK4PFchs') ), cms.PSet( record = cms.string('JetCorrectionsRecord'), tag = cms.string('JetCorrectorParametersCollection_Fall15_25nsV2_DATA_AK8PFchs'), label = cms.untracked.string('AK8PFchs') ))) process.es_prefer_jec = cms.ESPrefer('PoolDBESSource','jec') process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring(
# HTXS ======================================================================================================== if not isData and isHiggsSignal: process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi") process.mergedGenParticles = cms.EDProducer("MergedGenParticleProducer", inputPruned = cms.InputTag("prunedGenParticles"), inputPacked = cms.InputTag("packedGenParticles"), ) process.myGenerator = cms.EDProducer("GenParticles2HepMCConverter", genParticles = cms.InputTag("mergedGenParticles"), genEventInfo = cms.InputTag("generator"), signalParticlePdgIds = cms.vint32(25), ) process.rivetProducerHTXS = cms.EDProducer('HTXSRivetProducer', HepMCCollection = cms.InputTag('myGenerator','unsmeared'), LHERunInfo = cms.InputTag('externalLHEProducer'), ProductionMode = cms.string('AUTO'), ) process.htxsSequence = cms.Sequence( process.mergedGenParticles * process.myGenerator * process.rivetProducerHTXS ) else : process.htxsSequence = cms.Sequence( ) # END HTXS ==================================================================================================== # Pre-firing weights ========================================================================================== # https://twiki.cern.ch/twiki/bin/viewauth/CMS/L1ECALPrefiringWeightRecipe from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer if period == "2018" : process.prefiringweight = cms.Sequence() else: if period == '2016' : data_era = "2016BtoH"
process.SiStripCondObjBuilderFromDb.SiStripDetInfoFile = cms.FileInPath( "CalibTracker/SiStripCommon/data/SiStripDetInfo.dat") process.SiStripCondObjBuilderFromDb.UseAnalysis = True process.load("CondCore.DBCommon.CondDBCommon_cfi") process.CondDBCommon.connect = 'sqlite_file:dbfile.db' process.CondDBCommon.DBParameters.messageLevel = 4 process.CondDBCommon.DBParameters.authenticationPath = '/afs/cern.ch/cms/DB/conddb' process.PoolDBOutputService = cms.Service( "PoolDBOutputService", process.CondDBCommon, BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'), logconnect=cms.untracked.string('sqlite_file:log.db'), timetype=cms.untracked.string('runnumber'), toPut=cms.VPSet( cms.PSet(record=cms.string('SiStripApvGainRcd'), tag=cms.string('SiStripApvGain_test')))) process.CommonSiStripPopConParams = cms.PSet( SinceAppendMode=cms.bool(True), Source=cms.PSet(since=cms.untracked.uint32(1), name=cms.untracked.string('default'), debug=cms.untracked.bool(True)), loggingOn=cms.untracked.bool(True)) process.siStripPopConApvGain = cms.EDAnalyzer( "SiStripPopConApvGain", process.CommonSiStripPopConParams, record=cms.string('SiStripApvGainRcd')) process.siStripPopConApvGain.Source.name = 'siStripPopConApvGain'
import FWCore.ParameterSet.Config as cms gemDigiValidation = cms.EDAnalyzer( 'MuonGEMDigis', outputFile=cms.string(''), stripLabel=cms.InputTag('simMuonGEMDigis'), cscPadLabel=cms.InputTag('simMuonGEMCSCPadDigis'), cscCopadLabel=cms.InputTag('simMuonGEMCSCPadDigis', 'Coincidence'), simInputLabel=cms.InputTag('g4SimHits', "MuonGEMHits"), PlotBinInfo=cms.PSet( nBinGlobalZR=cms.untracked.vdouble(200, 200, 200, 150, 180, 250), RangeGlobalZR=cms.untracked.vdouble(564, 572, 786, 794, 794, 802, 110, 260, 170, 350, 100, 350), nBinGlobalXY=cms.untracked.int32(360), GE11PhiBegin=cms.untracked.double(-5), GE11PhiStep=cms.untracked.double(10), ), simTrackMatching=cms.PSet( #simInputLabel = cms.InputTag('g4SimHits',"MuonGEMHits"), simTrackCollection=cms.InputTag('g4SimHits'), simVertexCollection=cms.InputTag('g4SimHits'), verboseSimHit=cms.untracked.int32(0), # GEM digi matching: verboseGEMDigi=cms.untracked.int32(0), gemDigiInput=cms.untracked.InputTag("simMuonGEMDigis"), gemPadDigiInput=cms.untracked.InputTag("simMuonGEMCSCPadDigis"), gemCoPadDigiInput=cms.untracked.InputTag("simMuonGEMCSCPadDigis", "Coincidence"), minBXGEM=cms.untracked.int32(-1), maxBXGEM=cms.untracked.int32(1), matchDeltaStripGEM=cms.untracked.int32(1),
import FWCore.ParameterSet.Config as cms from RecoParticleFlow.PFClusterProducer.particleFlowCaloResolution_cfi import _timeResolutionHCAL _thresholdsHB = cms.vdouble(0.8, 0.8, 0.8, 0.8) _thresholdsHE = cms.vdouble(0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8) _thresholdsHBphase1 = cms.vdouble(0.1, 0.2, 0.3, 0.3) _thresholdsHEphase1 = cms.vdouble(0.1, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2) particleFlowRecHitHBHE = cms.EDProducer("PFRecHitProducer", navigator = cms.PSet( name = cms.string("PFRecHitHCALNavigator"), sigmaCut = cms.double(4.0), timeResolutionCalc = _timeResolutionHCAL ), producers = cms.VPSet( cms.PSet( name = cms.string("PFHBHERecHitCreator"), src = cms.InputTag("hbhereco",""), qualityTests = cms.VPSet( cms.PSet( name = cms.string("PFRecHitQTestHCALThresholdVsDepth"), cuts = cms.VPSet( cms.PSet( depth=cms.vint32(1, 2, 3, 4), threshold = _thresholdsHB, detectorEnum = cms.int32(1) ), cms.PSet( depth=cms.vint32(1, 2, 3, 4, 5, 6, 7), threshold = _thresholdsHE,
BusyInputSectorNumStubs = cms.uint32(175), # Naive value is 210. #BusyInputSectorNumStubs = cms.uint32(120), # Alternative proposal from Tom James for ultra compact firmware. # Multiplex the outputs from several HTs onto a single pair of output optical links? # Options: 0 = disable Mux; 1 = Dec. 2016 Mux; 2 = Mar 2018 Mux (for transverse HT readout by m-bin). # (The mux algorithm is hard-wired in class MuxHToutputs, and currently only works if option BusySectorMbinRanges is being used). MuxOutputsHT = cms.uint32(2), # If this is non-empty, then only the specified eta sectors are enabled, to study them individually. EtaRegWhitelist = cms.vuint32() ), #=== Options controlling r-z track filters (or any other track filters run after the Hough transform, as opposed to inside it). #=== (Irrelevant for track fitters that don't require any r-z filter run before them). RZfilterOpts = cms.PSet( # Specify preferred r-z filter (from those available inside TrkRZfilter.cc) - currently only "SeedFilter". RZFilterName = cms.string("SeedFilter"), #--- Options relevant for Seed filter, (so only relevant if rzFilterName="SeedFilter"). # Added resolution beyond that estimated from hit resolution. SeedResolution = cms.double(0.), # Store stubs compatible with all possible good seed. KeepAllSeed = cms.bool(False), # Maximum number of seed combinations to bother checking per track candidate. #MaxSeedCombinations = cms.uint32(999), MaxSeedCombinations = cms.uint32(15), # Maximum number of seed combinations consistent with (z0,eta) sector constraints to bother checking per track candidate. #MaxGoodSeedCombinations = cms.uint32(13), MaxGoodSeedCombinations = cms.uint32(10), # Maximum number of seeds that a single stub can be included in. MaxSeedsPerStub = cms.uint32(4), # Reject tracks whose estimated rapidity from seed filter is inconsistent range of with eta sector. (Kills some duplicate tracks). zTrkSectorCheck = cms.bool(True),
2.06042305E-06 2 24 35 # BR(Hp -> W HH) 3.51688173E-06 2 24 36 # BR(Hp -> W A0) DECAY 6 1.37127534E+00 # Gamma(top) 1.00000000E+00 2 5 24 # BR(top -> bottom W) """ import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * generator = cms.EDFilter("Pythia8GeneratorFilter", pythiaPylistVerbosity = cms.untracked.int32(1), filterEfficiency = cms.untracked.double(1), pythiaHepMCVerbosity = cms.untracked.bool(False), SLHATableForPythia8 = cms.string('%s' % SLHA_TABLE), comEnergy = cms.double(COM_ENERGY), crossSection = cms.untracked.double(CROSS_SECTION), maxEventsToPrint = cms.untracked.int32(1), PythiaParameters = cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, processParameters = cms.vstring( 'Higgs:useBSM = on', PROCESS, 'SLHA:allowUserOverride = off', 'SLHA:minMassSM = 100.', 'PhaseSpace:mHatMin = 56.0' ), parameterSets = cms.vstring( 'pythia8CommonSettings',
import FWCore.ParameterSet.Config as cms from FWCore.MessageLogger.MessageLogger_cfi import * process = cms.Process("MF") process.load("Configuration.StandardSequences.GeometryExtended_cff") process.load("Configuration.StandardSequences.MagneticField_38T_cff") process.XMLIdealGeometryESSource = cms.ESSource("XMLIdealGeometryESSource", geomXMLFiles = cms.vstring('Geometry/CMSCommonData/data/normal/cmsextent.xml', 'Geometry/CMSCommonData/data/cms.xml', 'Geometry/CMSCommonData/data/cmsMagneticField.xml', 'MagneticField/GeomBuilder/data/MagneticFieldVolumes_160812_1.xml', 'MagneticField/GeomBuilder/data/MagneticFieldVolumes_160812_2.xml', 'Geometry/CMSCommonData/data/materials.xml'), rootNodeName = cms.string('cms:MCMS') ) process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1) ) process.source = cms.Source("EmptySource") process.prod = cms.EDProducer("GeometryProducer", MagneticField = cms.PSet(delta = cms.double(1.0)), UseMagneticField = cms.bool(False), UseSensitiveDetectors = cms.bool(False) ) process.add_(cms.ESProducer("TGeoMgrFromDdd", verbose = cms.untracked.bool(False),
sys.path.insert(0, 'XMuMuAnalysis/NanoAODAnalyzer/scripts/') from ProcNanoAODSkim_Common import * # # Basic Configuration # era = "2017" debug = False nevents = -1 # # # ParameterSets for use in bin/<script>.cc # process = cms.PSet() # # LumiMask # process.inputs = cms.PSet(lumisToProcess=CfgTypes.untracked( CfgTypes.VLuminosityBlockRange()), ) # # # process.ProcessNanoAOD_XMuMu = cms.PSet( debug=cms.bool(debug), maxEvents=cms.int32(int(nevents)), inputListDir=cms.string(inputListDir_2018), outputListDir=cms.string(outputListDir), era=cms.string(era), blind=cms.bool(False), isMC=cms.bool(True), )
# \author Maria Teresa Grippo (University of Siena, INFN Pisa) # # Copyright 2011-2013 Subir Sarkar, Rosamaria Venditti (INFN Bari, Bari University) # Copyright 2014 Konstantin Androsov <*****@*****.**>, # Maria Teresa Grippo <*****@*****.**> # # This file is part of X->HH->bbTauTau. # # X->HH->bbTauTau is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # X->HH->bbTauTau is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with X->HH->bbTauTau. If not, see <http://www.gnu.org/licenses/>. import FWCore.ParameterSet.Config as cms muonBlock = cms.EDAnalyzer( "MuonBlock", muonSrc=cms.InputTag('patMuonsWithEmbeddedVariables'), vertexSrc=cms.InputTag('patVertices'), offlineBeamSpot=cms.InputTag('offlineBeamSpot'), beamSpotCorr=cms.bool(True), muonID=cms.string('GlobalMuonPromptTight'))
'90X_upgrade2017_realistic_v20', '') process.generator = cms.EDFilter( "Pythia8PtGun", PGunParameters=cms.PSet(AddAntiParticle=cms.bool(True), MaxEta=cms.double(2.5), MaxPhi=cms.double(3.14159265359), MaxPt=cms.double(10.01), MinEta=cms.double(-2.5), MinPhi=cms.double(-3.14159265359), MinPt=cms.double(9.99), ParticleID=cms.vint32(211)), PythiaParameters=cms.PSet(parameterSets=cms.vstring()), Verbosity=cms.untracked.int32(0), firstRun=cms.untracked.uint32(1), psethack=cms.string('single pi pt 10')) # Path and EndPath definitions process.generation_step = cms.Path(process.pgen) process.simulation_step = cms.Path(process.psim) process.digitisation_step = cms.Path(process.pdigi_valid) process.L1simulation_step = cms.Path(process.SimL1Emulator) process.digi2raw_step = cms.Path(process.DigiToRaw) process.raw2digi_step = cms.Path(process.RawToDigi) process.reconstruction_step = cms.Path(process.reconstruction) process.genfiltersummary_step = cms.EndPath(process.genFilterSummary) process.endjob_step = cms.EndPath(process.endOfProcess) process.FEVTDEBUGoutput_step = cms.EndPath(process.FEVTDEBUGoutput) # Schedule definition process.schedule = cms.Schedule(