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 DisableQCuts(sequence): scanner = Scanner() sequence.visit(scanner) disabled = cms.PSet( isolationQualityCuts = cms.PSet( minTrackHits = cms.uint32(0), minTrackVertexWeight = cms.double(-1), minTrackPt = cms.double(0), maxTrackChi2 = cms.double(9999), minTrackPixelHits = cms.uint32(0), minGammaEt = cms.double(0), maxDeltaZ = cms.double(0.2), maxTransverseImpactParameter = cms.double(9999) ), pvFindingAlgo = cms.string('highestWeightForLeadTrack'), primaryVertexSrc = cms.InputTag("offlinePrimaryVertices"), signalQualityCuts = cms.PSet( minTrackHits = cms.uint32(0), minTrackVertexWeight = cms.double(-1), minTrackPt = cms.double(0), maxTrackChi2 = cms.double(9999), minTrackPixelHits = cms.uint32(0), minGammaEt = cms.double(0), maxDeltaZ = cms.double(0.2), maxTransverseImpactParameter = cms.double(9999) ) ) for module in scanner.modules(): if hasattr(module,'qualityCuts'): setattr(module,'qualityCuts',disabled)
def eleMomentumRegression(process, datasetpath, datatype): # generate hash from datasetpath and form unique but constant seed for each sample # !!! WARNING: seed is still dependent on job splitting !!! to_hash = datasetpath hash_input = to_hash.split("=")[1].strip() generate_hash = hashlib.md5(hash_input) seed = abs(int(str(int(generate_hash.hexdigest(),16))[0:9])) # crab expects uint32 -> only up to 9 digits of hash can be safely used process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService", calibratedElectrons = cms.PSet( initialSeed = cms.untracked.uint32(seed), engineName = cms.untracked.string("TRandom3") ), ) process.load("EgammaAnalysis.ElectronTools.calibratedElectrons_cfi") if datatype == "Data" or "embedded" in datatype: process.calibratedElectrons.isMC = cms.bool(False) process.calibratedElectrons.inputDataset = cms.string("22Jan2013ReReco") else: process.calibratedElectrons.isMC = cms.bool(True) process.calibratedElectrons.inputDataset = cms.string("Summer12_LegacyPaper") process.calibratedElectrons.updateEnergyError = cms.bool(True) process.calibratedElectrons.correctionsType = cms.int32(2) process.calibratedElectrons.combinationType = cms.int32(3) process.calibratedElectrons.applyLinearityCorrection = cms.bool(True) process.load('EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi') process.eleRegressionEnergy.inputElectronsTag = cms.InputTag('gsfElectrons') process.eleRegressionEnergy.inputCollectionType = cms.uint32(0) process.eleRegressionEnergy.useRecHitCollections = cms.bool(True) process.eleRegressionEnergy.produceValueMaps = cms.bool(True) process.eleRegressionEnergy.regressionInputFile = cms.string("EgammaAnalysis/ElectronTools/data/eleEnergyRegWeights_WithSubClusters_VApr15.root") process.eleRegressionEnergy.energyRegressionType = cms.uint32(2)
def addMuTauSelection(process): process.selectedPatTaus.cut = hpsTauSelection process.selectedPatMuons.cut = muonSelection process.zmutauAllEvents = cms.EDProducer("EventCountProducer") process.selectedTauFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("selectedPatTaus"), minNumber = cms.uint32(1), ) process.selectedMuonFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("selectedPatMuons"), minNumber = cms.uint32(1), ) process.muTauPairs = muTauPairs.clone() process.muTauPairsFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag('muTauPairs'), minNumber = cms.uint32(1), ) process.zmutauSelectedEvents = cms.EDProducer("EventCountProducer") return cms.Sequence( process.zmutauAllEvents + process.selectedTauFilter + process.selectedMuonFilter + process.muTauPairs + process.muTauPairsFilter + process.zmutauSelectedEvents )
def makeTnPFitter(process, suffix, category): fitter = cms.EDAnalyzer("TagProbeFitTreeAnalyzer", #InputFileNames = cms.vstring("ntuple/0j/tnpTree_%s.root" % mode), InputFileNames = cms.vstring("ntuple/ntuple_%s.root" % mode), InputDirectoryName = cms.string("tnp"+suffix), InputTreeName = cms.string("fitter_tree"), OutputFileName = cms.string("result/unmerged/result_%s_%s_%s.root" % (suffix, category, mode)), 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", "60.0", "120.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", ""), event_nJet = cms.vstring("Jet multiplicity", "0", "5", ""), pair_dz = cms.vstring("#Delta z", "0", "0.3", "cm"), weight = cms.vstring("Weight", "0.0", "2.0", ""), ), Categories = cms.PSet(), PDFs = basicPDFs, binnedFit = cms.bool(True), binsForFit = cms.uint32(100), Quiet = cms.untracked.bool(True), ) setattr(fitter, 'Efficiencies', tnpEffPSet(category)) setattr(fitter.Categories, category, cms.vstring(category, "dummy[pass=1,fail=0]")) setattr(process, 'fit'+suffix, fitter) process.p += getattr(process, 'fit'+suffix)
def setMaxNumberVertices(process,maxnum): print "Max number of vertices in each event (GoodVertices, SumPtOrdVertices) set to", maxnum process.sortedGoodVertices.maxNumber=cms.uint32(maxnum) process.sortedSumPtOrdVertices.maxNumber=cms.uint32(maxnum) print "double-check (GoodVertices): ", process.sortedGoodVertices.maxNumber print "double-check (SumPtOrdVertices): ", process.sortedSumPtOrdVertices.maxNumber return process
def BuildDigi(strip, adc, noise, gain, quality) : return cms.PSet( Strip = cms.uint32(strip), ADC = cms.uint32(adc), Noise = cms.uint32(noise), Gain = cms.uint32(gain), Quality = cms.uint32(quality) )
def customise_TrackTrigger(process): process.TTStubAlgorithm_tab2013_PixelDigi_ = cms.ESProducer("TTStubAlgorithm_tab2013_PixelDigi_", zMatchingPS = cms.bool(False), zMatching2S = cms.bool(True), BarrelCut = cms.vdouble( 0, 2.5, 2.5, 3, 3, 4.5, 4.5, 5.5, 5.5, 7, 7 ), #Use 0 as dummy to have direct access using DetId to the correct element EndcapCutSet = cms.VPSet( cms.PSet( EndcapCut = cms.vdouble( 0 ) ), #Use 0 as dummy to have direct access using DetId to the correct element ) ) process.StackedTrackerGeometryESModule = cms.ESProducer( "StackedTrackerGeometryESModule", truncation_precision = cms.uint32(2), z_window = cms.double(4.0), phi_window = cms.double(0.015), radial_window = cms.double(1.0), make_debug_file = cms.bool(True), # Extras for CBC3 chip partitionsPerRoc = cms.int32(4), CBC3_MaxStubs = cms.uint32(3), # Double tab2013 table as CBC3 chip uses full width -- this table for LB's (not verified numbers) design BarrelCut = cms.vdouble( 0, 5, 5, 6, 6, 9, 9, 11, 11, 14, 14 ), #Use 0 as dummy to have direct access using DetId to the correct element EndcapCutSet = cms.VPSet( cms.PSet( EndcapCut = cms.vdouble( 0 ) ), #Use 0 as dummy to have direct access using DetId to the correct element ) ) return process
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 apply(self, process): src=self._parameters['src'].value patLabel =self._parameters['patLabel'].value cut=self._parameters['cut'].value if hasattr(process, "addAction"): process.disableRecording() from PhysicsTools.PatAlgos.producersLayer1.pfParticleProducer_cfi import allLayer1PFParticles # make modules producer = allLayer1PFParticles.clone(pfCandidateSource = src) filter = cms.EDFilter("PATPFParticleSelector", src = cms.InputTag('allLayer1' + patLabel), cut = cms.string(cut)) counter = cms.EDFilter("PATCandViewCountFilter", minNumber = cms.uint32(0), maxNumber = cms.uint32(999999), src = cms.InputTag('selectedLayer1' + patLabel)) # add modules to process setattr(process, 'allLayer1' + patLabel, producer) setattr(process, 'selectedLayer1' + patLabel, filter) setattr(process, 'countLayer1' + patLabel, counter) # insert into sequence process.allLayer1Objects.replace(process.allLayer1Summary, producer + process.allLayer1Summary) process.selectedLayer1Objects.replace(process.selectedLayer1Summary, filter + process.selectedLayer1Summary) process.countLayer1Objects += counter # summary tables process.allLayer1Summary.candidates.append(cms.InputTag('allLayer1' + patLabel)) process.selectedLayer1Summary.candidates.append(cms.InputTag('selectedLayer1' + patLabel)) if hasattr(process, "addAction"): process.enableRecording() action=self.__copy__() process.addAction(action)
def addPFCandidates(process,src,patLabel='PFParticles',cut="",postfix=""): from PhysicsTools.PatAlgos.producersLayer1.pfParticleProducer_cfi import patPFParticles # make modules producer = patPFParticles.clone(pfCandidateSource = src) filter = cms.EDFilter("PATPFParticleSelector", src = cms.InputTag("pat" + patLabel), cut = cms.string(cut)) counter = cms.EDFilter("PATCandViewCountFilter", minNumber = cms.uint32(0), maxNumber = cms.uint32(999999), src = cms.InputTag("pat" + patLabel)) # add modules to process setattr(process, "pat" + patLabel, producer) setattr(process, "selectedPat" + patLabel, filter) setattr(process, "countPat" + patLabel, counter) # insert into sequence getattr(process, "patDefaultSequence"+postfix).replace( applyPostfix(process, "patCandidateSummary", postfix), producer+applyPostfix(process, "patCandidateSummary", postfix) ) getattr(process, "patDefaultSequence"+postfix).replace( applyPostfix(process, "selectedPatCandidateSummary", postfix), filter+applyPostfix(process, "selectedPatCandidateSummary", postfix) ) index = len( applyPostfix( process, "patDefaultSequence", postfix ).moduleNames() ) applyPostfix( process, "patDefaultSequence", postfix ).insert( index, counter ) # summary tables applyPostfix(process, "patCandidateSummary", postfix).candidates.append(cms.InputTag('pat' + patLabel)) applyPostfix(process, "selectedPatCandidateSummary", postfix).candidates.append(cms.InputTag('selectedPat' + patLabel))
def addMuTauSelection(process): process.selectedPatTausHpsPFTau.cut = hpsTauSelection process.selectedPatMuons.cut = muonSelection process.selectedTauFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("selectedPatTausHpsPFTau"), minNumber = cms.uint32(1), ) process.selectedMuonFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("selectedPatMuons"), minNumber = cms.uint32(1), ) process.muTauPairs = muTauPairs.clone() process.muTauPairsFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag('muTauPairs'), minNumber = cms.uint32(1), ) return cms.Sequence( process.selectedTauFilter + process.selectedMuonFilter + process.muTauPairs + process.muTauPairsFilter )
def psetMissingHitsCut(wpEB, wpEE): return cms.PSet( cutName = cms.string('GsfEleMissingHitsCut'), maxMissingHitsEB = cms.uint32( wpEB.missingHitsCut ), maxMissingHitsEE = cms.uint32( wpEE.missingHitsCut ), barrelCutOff = cms.double(ebCutOff), needsAdditionalProducts = cms.bool(False), isIgnored = cms.bool(False) )
def addGenuineTauPreselection(process, sequence, param, prefix="genuineTauPreselection", pileupWeight=None, maxGenTaus=None): counters = [] genTauSequence = cms.Sequence() # Create PU weight producer for the counters if pileupWeight == None: puModule = cms.EDProducer("HPlusVertexWeightProducer", alias = cms.string("pileupWeight"), histogramAmbientLevel = cms.untracked.string("Systematics") ) HChTools.insertPSetContentsTo(param.vertexWeight.clone(), puModule) pileupWeight = prefix+"PileupWeight" setattr(process, pileupWeight, puModule) genTauSequence *= puModule counterPrototype = cms.EDProducer("HPlusEventCountProducer", weightSrc = cms.InputTag(pileupWeight) ) allCount = counterPrototype.clone() setattr(process, prefix+"AllCount", allCount) counters.append(prefix+"AllCount") # Generator taus (if you modify this, remember to modify similar in below) genTaus = cms.EDFilter("GenParticleSelector", src = cms.InputTag("genParticles"), cut = cms.string(generatorTauSelection % generatorTauPt) ) genTausName = prefix+"GenTau" setattr(process, genTausName, genTaus) if maxGenTaus is not None: genTausFilter = cms.EDFilter("PATCandViewCountFilter", src = cms.InputTag(genTausName), minNumber = cms.uint32(1), maxNumber = cms.uint32(maxGenTaus), ) else: genTausFilter = cms.EDFilter("CandViewCountFilter", src = cms.InputTag(genTausName), minNumber = cms.uint32(1), ) setattr(process, prefix+"GenTauFilter", genTausFilter) genTausCount = counterPrototype.clone() setattr(process, prefix+"GenTauCount", genTausCount) counters.append(prefix+"GenTauCount") genTauSequence *= ( allCount * genTaus * genTausFilter * genTausCount ) setattr(process, prefix+"Sequence", genTauSequence) sequence *= genTauSequence return counters
def create_compression(process, exponent=4, mantissa=4, rounding=True ): producer = process.hgcalVFEProducer.clone() producer.ProcessorParameters.exponentBits = cms.uint32(exponent) producer.ProcessorParameters.mantissaBits = cms.uint32(mantissa) producer.ProcessorParameters.rounding = cms.bool(rounding) return producer
def makeCountFilter(src, minNumber, maxNumber=None): if maxNumber == None: return cms.EDFilter("CandViewCountFilter", src = src, minNumber = cms.uint32(minNumber)) else: return cms.EDFilter("PATCandViewCountFilter", src = src, minNumber = cms.uint32(minNumber), maxNumber = cms.uint32(maxNumber))
def customise(process): process.trackerGeometry.trackerGeometryConstants = cms.PSet(trackerGeometryConstants_cfi.trackerGeometryConstants) process.idealForDigiTrackerGeometry.trackerGeometryConstants = cms.PSet(trackerGeometryConstants_cfi.trackerGeometryConstants) process.trackerNumberingGeometry.fromDDD = cms.bool( True ) process.trackerNumberingGeometry.layerNumberPXB = cms.uint32(18) process.trackerNumberingGeometry.totalBlade = cms.uint32(56) return process
def customiseL1Muons(process, customDTTF=True, customCSCTF=True, customPACT=True, customGMT=True, dttfFile = "sqlite_file:crab/dttf_config.db"): print "[L1Menu]: Customising muon chain with 2015 improvements" if customDTTF and hasattr(process,"dttfReEmulDigis") : print "[L1Menu]:\tCustomising DTTF LUTs" process.GlobalTag.toGet.extend( cms.VPSet(cms.PSet(record = cms.string("L1MuDTEtaPatternLutRcd"), tag = cms.string("L1MuDTEtaPatternLut_CRAFT09_hlt"), connect = cms.untracked.string(dttfFile) ), cms.PSet(record = cms.string("L1MuDTExtLutRcd"), tag = cms.string("L1MuDTExtLut_CRAFT09_hlt"), connect = cms.untracked.string(dttfFile) ), cms.PSet(record = cms.string("L1MuDTPhiLutRcd"), tag = cms.string("L1MuDTPhiLut_CRAFT09_hlt"), connect = cms.untracked.string(dttfFile) ), cms.PSet(record = cms.string("L1MuDTPtaLutRcd"), tag = cms.string("L1MuDTPtaLut_CRAFT09_hlt"), connect = cms.untracked.string(dttfFile) ), cms.PSet(record = cms.string("L1MuDTQualPatternLutRcd"), tag = cms.string("L1MuDTQualPatternLut_CRAFT09_hlt"), connect = cms.untracked.string(dttfFile) ) ) ) if customPACT and hasattr(process,"rpcTriggerReEmulDigis") : print "[L1Menu]:\tCustomising PACT patterns" patternDirectory = "L1TriggerDPG/L1Menu/data/rpc_patterns/xml/" process.load("L1TriggerConfig.RPCTriggerConfig.RPCConeDefinition_cff") process.load("L1TriggerConfig.RPCTriggerConfig.L1RPCConfig_cff") process.load("L1Trigger.RPCTrigger.RPCConeConfig_cff") process.rpcconf.filedir = cms.untracked.string(patternDirectory) process.es_prefer_rpcPats = cms.ESPrefer("RPCTriggerConfig","rpcconf") if customGMT and hasattr(process,"gmtReEmulDigis") : print "[L1Menu]:\tCustomising GMT to use min-pt" process.load('L1TriggerConfig.GMTConfigProducers.L1MuGMTParameters_cfi') process.L1MuGMTParameters.MergeMethodPtBrl=cms.string("byMinPt") process.L1MuGMTParameters.MergeMethodPtFwd=cms.string("byMinPt") process.L1MuGMTParameters.VersionSortRankEtaQLUT = cms.uint32(275) process.L1MuGMTParameters.VersionLUTs = cms.uint32(1) process.es_prefer_gmtConfig = cms.ESPrefer("L1MuGMTParametersProducer","L1MuGMTParameters")
def addCandidateMETModule(self,moduleName,moduleType, srcLeptons,srcMET,srcJets,min = 1,max=9999,text = '',genParticles = 'genWs'): dicand = cms.EDProducer(moduleType) dicand.SimBHadronCollection = cms.InputTag("bhadrons") dicand.srcLeptons = cms.InputTag(srcLeptons) dicand.srcMET = cms.InputTag(srcMET) dicand.srcJets = cms.InputTag(srcJets) dicand.verbosity = cms.untracked.int32(0) dicand.srcGenParticles = cms.InputTag(genParticles) dicand.metCalibration = cms.PSet( applyCalibration = cms.bool(False), calibrationScheme = cms.string("OneLeg"), responseU1 = cms.string("1.33223-0.917782*x"), responseU2 = cms.string("-0.013"), resolutionU1 = cms.string("11.1566+0.0654529*x+0.000124436*x*x"), resolutionU2 = cms.string("11.1235+0.0449872*x-6.39822e-5*x*x"), responseMCU1 = cms.string("1.26247-0.950094*x"), responseMCU2 = cms.string("-0.00544907"), resolutionMCU1 = cms.string("10.6449+0.0436475*x+3.07554e-5*x*x"), resolutionMCU2 = cms.string("10.5649+0.0225853*x-5.81371e-5*x*x") ) pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,moduleName,dicand) self.sequence*=dicand self.input=moduleName #Create the Filter filter = cms.EDFilter("PATCandViewCountFilter") filter.minNumber = cms.uint32(min) filter.maxNumber = cms.uint32(max) filter.src = cms.InputTag(moduleName) filterName = moduleName+'Filter' filter.setLabel(filterName) #Register the filter in the namespace pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,filterName,filter) self.sequence*=filter #now the counter if text is not '': counter = cms.EDProducer("EventCounter") counter.name=cms.string(text) counterName = moduleName+'Counter' counter.setLabel(counterName) pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,counterName,counter) self.sequence*=counter
def BuildNewAlgo(algorithm, channelThreshold, seedThreshold, clusterThreshold, maxSequentialHoles, maxSequentialBad, maxAdjacentBad, qualityLabel) : return cms.PSet( Algorithm = cms.string(algorithm), ChannelThreshold = cms.double(channelThreshold), SeedThreshold = cms.double(seedThreshold), ClusterThreshold = cms.double(clusterThreshold), MaxSequentialHoles = cms.uint32(maxSequentialHoles), MaxSequentialBad = cms.uint32(maxSequentialBad), MaxAdjacentBad = cms.uint32(maxAdjacentBad), QualityLabel = cms.string(qualityLabel) )
def getRefittedVerticesForTauPair(process, vertexColl, tauColl, postfix="") : print "getRefittedVerticesForTauPair:" process.diTauPrimaryVertices = cms.EDProducer("DiTauPrimaryVertexProducer", PFTauTagLeg1 = cms.InputTag(tauColl), PFTauTagLeg2 = cms.InputTag(tauColl), PVTag = cms.InputTag(vertexColl), beamSpot = cms.InputTag("offlineBeamSpot"), TrackCollectionTag = cms.InputTag("generalTracks"), useBeamSpot = cms.bool(False) ) #Make pair of taus and re-fit vertex for each pair diTauInputList = [] runVtxReFitSequence = cms.Sequence() for idxLeg1 in range(5): for idxLeg2 in range(5): srcLeg1 = None if idxLeg2 <= idxLeg1: continue moduleNameLeg1 = "%sLeg1comb%i%i%s" % (tauColl, idxLeg1, idxLeg2, postfix) moduleLeg1 = cms.EDProducer("SinglePatTauPicker", src = cms.InputTag(tauColl), itemNumber = cms.uint32(idxLeg1), verbose = cms.untracked.bool(False) ) setattr(process, moduleNameLeg1, moduleLeg1) runVtxReFitSequence += moduleLeg1 srcLeg1 = moduleNameLeg1 moduleNameLeg2 = "%sLeg2comb%i%i%s" % (tauColl, idxLeg1, idxLeg2, postfix) moduleLeg2 = cms.EDProducer("SinglePatTauPicker", src = cms.InputTag(tauColl), itemNumber = cms.uint32(idxLeg2), verbose = cms.untracked.bool(False) ) setattr(process, moduleNameLeg2, moduleLeg2) runVtxReFitSequence += moduleLeg2 srcLeg2 = moduleNameLeg2 moduleNameVtxFit = "diTauPrimaryVertexComb%i%i%s" % (idxLeg1, idxLeg2 ,postfix) moduleVtxReFit = process.diTauPrimaryVertices.clone( PFTauTagLeg1 = cms.InputTag(srcLeg1), PFTauTagLeg2 = cms.InputTag(srcLeg2) ) setattr(process, moduleNameVtxFit, moduleVtxReFit) runVtxReFitSequence += moduleVtxReFit runVtxReFitSequenceName = "runVtxReFitSequence%s" % postfix setattr(process, runVtxReFitSequenceName, runVtxReFitSequence) return runVtxReFitSequence
def customise_condOverRides(process): process.trackerTopologyConstants.pxb_layerStartBit = cms.uint32(20) process.trackerTopologyConstants.pxb_ladderStartBit = cms.uint32(12) process.trackerTopologyConstants.pxb_moduleStartBit = cms.uint32(2) process.trackerTopologyConstants.pxb_layerMask = cms.uint32(15) process.trackerTopologyConstants.pxb_ladderMask = cms.uint32(255) process.trackerTopologyConstants.pxb_moduleMask = cms.uint32(1023) process.trackerTopologyConstants.pxf_diskStartBit = cms.uint32(18) process.trackerTopologyConstants.pxf_bladeStartBit = cms.uint32(12) process.trackerTopologyConstants.pxf_panelStartBit = cms.uint32(10) process.trackerTopologyConstants.pxf_moduleMask = cms.uint32(255) return process
def CreateAllTowerJetPermutations(process): RingSubtractionMethods = ["Mean", "Median", "Constant"] TowerJetSizes = [8, 9, 10, 12] TowerJetShapes = ["Circle", "Square"] lReturnSequence = cms.Sequence() for RingSubtractionMethod in RingSubtractionMethods: lReturnSequence += NewNamedModule( process, RingSubtractionMethod + "RingSubtractedTower", cms.EDProducer( "L1RingSubtractionProducer", src=cms.InputTag("L1CaloTowerProducer"), RingSubtractionType=cms.string(RingSubtractionMethod), ), ) for TowerJetShape in TowerJetShapes: for TowerJetSize in TowerJetSizes: lReturnSequence += NewNamedModule( process, "TowerJet" + TowerJetShape + str(TowerJetSize) + "FromL1CaloTower", cms.EDProducer( "L1TowerJetProducer", src=cms.InputTag("L1CaloTowerProducer"), JetDiameter=cms.uint32(TowerJetSize), JetShape=cms.string(TowerJetShape), ), ) for RingSubtractionMethod in RingSubtractionMethods: lReturnSequence += NewNamedModule( process, "TowerJet" + TowerJetShape + str(TowerJetSize) + "From" + RingSubtractionMethod + "RingSubtractedTower", cms.EDProducer( "L1TowerJetProducer", src=cms.InputTag(RingSubtractionMethod + "RingSubtractedTower"), JetDiameter=cms.uint32(TowerJetSize), JetShape=cms.string(TowerJetShape), ), ) return lReturnSequence
def customise_condOverRides(process): # process.load('SLHCUpgradeSimulations.Geometry.fakeConditions_Phase1_R30F12_cff') process.trackerTopologyConstants.pxb_layerStartBit = cms.uint32(20) process.trackerTopologyConstants.pxb_ladderStartBit = cms.uint32(12) process.trackerTopologyConstants.pxb_moduleStartBit = cms.uint32(2) process.trackerTopologyConstants.pxb_layerMask = cms.uint32(15) process.trackerTopologyConstants.pxb_ladderMask = cms.uint32(255) process.trackerTopologyConstants.pxb_moduleMask = cms.uint32(1023) process.trackerTopologyConstants.pxf_diskStartBit = cms.uint32(18) process.trackerTopologyConstants.pxf_bladeStartBit = cms.uint32(12) process.trackerTopologyConstants.pxf_panelStartBit = cms.uint32(10) process.trackerTopologyConstants.pxf_moduleMask = cms.uint32(255) return process
def custom_3dclustering_histoMax(process, distance = 0.01, nBins_R = 36, nBins_Phi = 216, binSumsHisto = binSums, ): parameters_c3d = process.hgcalBackEndLayer2Producer.ProcessorParameters.C3d_parameters parameters_c3d.dR_multicluster = cms.double(distance) parameters_c3d.nBins_R_histo_multicluster = cms.uint32(nBins_R) parameters_c3d.nBins_Phi_histo_multicluster = cms.uint32(nBins_Phi) parameters_c3d.binSumsHisto = binSumsHisto parameters_c3d.type_multicluster = cms.string('HistoMaxC3d') return process
def configureDiMuonVetoFilter(process) : process.globalMuons = cms.EDFilter("PATMuonSelector", src = cms.InputTag('patMuons'), cut = cms.string("isGlobalMuon"), filter = cms.bool(False) ) process.diMuonVeto = cms.EDFilter("PATCandViewCountFilter", src = cms.InputTag('globalMuons'), minNumber = cms.uint32(1), maxNumber = cms.uint32(1) ) process.diMuVetoFilter = cms.Sequence(process.globalMuons*process.diMuonVeto)
def customiseSimL1EmulatorForPostLS1_Additional_HI(process): # set the Stage 1 heavy ions-specific parameters # all of these should eventually end up in a GT if hasattr(process,'RCTConfigProducers'): process.RCTConfigProducers.eicIsolationThreshold = cms.uint32(7) process.RCTConfigProducers.hOeCut = cms.double(999) process.RCTConfigProducers.eMinForHoECut = cms.double(999) process.RCTConfigProducers.eMaxForHoECut = cms.double(999) process.RCTConfigProducers.hMinForHoECut = cms.double(999) process.RCTConfigProducers.eMinForFGCut = cms.double(999) if hasattr(process,'caloConfig'): process.caloConfig.fwVersionLayer2 = cms.uint32(1) return process
def addDiCandidateModule(self,moduleName,moduleType, src1,src2,met,taus,jets,min = 1,max=9999,text = '',leadingObjectsOnly = False,dR = 0.3,recoMode = "",genParticles = 'genTaus'): dicand = cms.EDProducer(moduleType) dicand.useLeadingTausOnly = cms.bool(False) dicand.srcLeg1 = cms.InputTag(src1) dicand.srcLeg2 = cms.InputTag(src2) dicand.srcJets = cms.InputTag(jets) dicand.dRmin12 = cms.double(dR) dicand.srcMET = cms.InputTag(met) dicand.srcTaus = cms.InputTag(taus) dicand.srcPrimaryVertex = cms.InputTag("offlinePrimaryVertices") dicand.srcBeamSpot = cms.InputTag("offlineBeamSpot") dicand.srcGenParticles = cms.InputTag(genParticles) dicand.recoMode = cms.string("") dicand.verbosity = cms.untracked.int32(0) dicand.doSVreco = cms.bool(False) dicand.metCalibration = metCalibration pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,moduleName,dicand) self.sequence*=dicand self.input=moduleName #Create the Filter filter = cms.EDFilter("PATCandViewCountFilter") filter.minNumber = cms.uint32(min) filter.maxNumber = cms.uint32(max) filter.src = cms.InputTag(moduleName) filterName = moduleName+'Filter' filter.setLabel(filterName) #Register the filter in the namespace pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,filterName,filter) self.sequence*=filter #now the counter if text is not '': counter = cms.EDProducer("EventCounter") counter.name=cms.string(text) counterName = moduleName+'Counter' counter.setLabel(counterName) pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule,counterName,counter) self.sequence*=counter
def L1TReEmulFromRAW2015(process): process.load('L1Trigger.Configuration.SimL1Emulator_cff') process.load('L1Trigger.Configuration.CaloTriggerPrimitives_cff') process.simEcalTriggerPrimitiveDigis.Label = 'ecalDigis' process.simHcalTriggerPrimitiveDigis.inputLabel = cms.VInputTag( cms.InputTag('hcalDigis'), cms.InputTag('hcalDigis') ) process.L1TReEmul = cms.Sequence(process.simEcalTriggerPrimitiveDigis * process.simHcalTriggerPrimitiveDigis * process.SimL1Emulator) process.simDtTriggerPrimitiveDigis.digiTag = 'muonDTDigis' process.simCscTriggerPrimitiveDigis.CSCComparatorDigiProducer = cms.InputTag( 'muonCSCDigis', 'MuonCSCComparatorDigi') process.simCscTriggerPrimitiveDigis.CSCWireDigiProducer = cms.InputTag( 'muonCSCDigis', 'MuonCSCWireDigi' ) if hasattr(process, "stage2L1Trigger"): process.simTwinMuxDigis.RPC_Source = cms.InputTag('muonRPCDigis') # When available, this will switch to TwinMux input Digis: process.simTwinMuxDigis.DTDigi_Source = cms.InputTag("dttfDigis") process.simTwinMuxDigis.DTThetaDigi_Source = cms.InputTag("dttfDigis") process.simOmtfDigis.srcRPC = cms.InputTag('muonRPCDigis') process.simBmtfDigis.DTDigi_Source = cms.InputTag("simTwinMuxDigis") process.simBmtfDigis.DTDigi_Theta_Source = cms.InputTag("dttfDigis") process.simEmtfDigis.CSCInput = cms.InputTag("csctfDigis") process.simEmtfDigis.RPCInput = cms.InputTag('muonRPCDigis') process.simOmtfDigis.srcCSC = cms.InputTag("csctfDigis") process.simCaloStage2Layer1Digis.ecalToken = cms.InputTag("ecalDigis:EcalTriggerPrimitives") process.L1TReEmulPath = cms.Path(process.L1TReEmul) process.schedule.append(process.L1TReEmulPath) print "L1TReEmul sequence: " print process.L1TReEmul print process.schedule # quiet warning abouts missing Stage-2 payloads, since they won't reliably exist in 2015 data. if hasattr(process, "caloStage2Digis"): process.caloStage2Digis.MinFeds = cms.uint32(0) if hasattr(process, "gmtStage2Digis"): process.gmtStage2Digis.MinFeds = cms.uint32(0) if hasattr(process, "gtStage2Digis"): process.gtStage2Digis.MinFeds = cms.uint32(0) return process else: process.simRctDigis.ecalDigis = cms.VInputTag('simEcalTriggerPrimitiveDigis') process.simRctDigis.hcalDigis = cms.VInputTag('simHcalTriggerPrimitiveDigis') process.simRpcTriggerDigis.label = 'muonRPCDigis' process.simRpcTechTrigDigis.RPCDigiLabel = 'muonRPCDigis' process.L1TReEmulPath = cms.Path(process.L1TReEmul) process.schedule.append(process.L1TReEmulPath) print "L1TReEmul sequence: " print process.L1TReEmul print process.schedule return process
def addMuonIsolation(process, sequence, prefix, isolation): selector = prefix+"Selected" filter = prefix+"Filter" counter = prefix # Create modules m1 = cms.EDFilter("HPlusCandViewLazyPtrSelector", src = cms.InputTag(tauEmbeddingMuons), cut = cms.string(isolation) ) m2 = cms.EDFilter("CandViewCountFilter", src = cms.InputTag(selector), minNumber = cms.uint32(1) ) m3 = cms.EDProducer("EventCountProducer") # Add modules to process setattr(process, selector, m1) setattr(process, filter, m2) setattr(process, counter, m3) # Add modules to sequence sequence *= (m1 * m2 * m3) # Return list of counter names return [counter]
values=cms.vdouble([x * fC_per_ele for x in nonAgedNoises]), #100,200,300 um ) HGCAL_noise_MIP = cms.PSet(value=cms.double(1.0 / 7.0)) HGCAL_chargeCollectionEfficiencies = cms.PSet(values=cms.vdouble(nonAgedCCEs)) HGCAL_noises = cms.PSet(values=cms.vdouble([x for x in nonAgedNoises])) # ECAL hgceeDigitizer = cms.PSet( accumulatorType=cms.string("HGCDigiProducer"), hitCollection=cms.string("HGCHitsEE"), digiCollection=cms.string("HGCDigisEE"), maxSimHitsAccTime=cms.uint32(100), bxTime=cms.double(25), eVPerEleHolePair=cms.double(eV_per_eh_pair), tofDelay=cms.double(5), digitizationType=cms.uint32(0), makeDigiSimLinks=cms.bool(False), useAllChannels=cms.bool(True), verbosity=cms.untracked.uint32(0), digiCfg=cms.PSet( keV2fC=cms.double( 0.044259), #1000 eV/3.62 (eV per e) / 6.24150934e3 (e per fC) chargeCollectionEfficiencies=cms.PSet( refToPSet_=cms.string("HGCAL_chargeCollectionEfficiencies")), noise_fC=cms.PSet(refToPSet_=cms.string("HGCAL_noise_fC")), doTimeSamples=cms.bool(False), feCfg=cms.PSet(
cut /= 2.0 newDecayMode = copy.deepcopy(dm) newDecayMode.cut = cms.double(cut) newDecayModes.append(newDecayMode) producer.decayModes = newDecayModes TauDecayModeCutMutliplexerPrototype = cms.EDProducer( "RecoTauDecayModeCutMultiplexer", PFTauProducer=cms.InputTag("shrinkingConePFTauProducer"), toMultiplex=cms.InputTag('shrinkingConePFTauDiscriminationByTaNC'), Prediscriminants=shrinkingConeLeadTrackFinding, #computers = TaNC, decayModes=cms.VPSet( cms.PSet( nCharged=cms.uint32(1), nPiZeros=cms.uint32(0), ), cms.PSet( nCharged=cms.uint32(1), nPiZeros=cms.uint32(1), ), cms.PSet( nCharged=cms.uint32(1), nPiZeros=cms.uint32(2), ), cms.PSet( nCharged=cms.uint32(3), nPiZeros=cms.uint32(0), ), cms.PSet(
destinations=cms.untracked.vstring('cout', 'readFromFile_RUNNUMBER'), readFromFile_RUNNUMBER=cms.untracked.PSet( threshold=cms.untracked.string('DEBUG')), debugModules=cms.untracked.vstring('*')) ######################### # maxEvents ... ######################### process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1)) process.source = cms.Source("EmptySource", timetype=cms.string("runnumber"), firstRun=cms.untracked.uint32(1), lastRun=cms.untracked.uint32(1), interval=cms.uint32(1)) ######################### # DQM services ######################### process.load("DQMServices.Core.DQM_cfg") #from DQMServices.Core.DQM_cfg import * ######################## # DB parameters ######################## process.PoolDBOutputService = cms.Service( "PoolDBOutputService", #connect = cms.string("sqlite_file:historicDQM.db"), BlobStreamerName=cms.untracked.string('TBufferBlobStreamingService'),
import FWCore.ParameterSet.Config as cms from RecoMET.METFilters.CSCTightHaloFilter_cfi import * CSCTightHaloFilter.taggingMode = cms.bool(True) from RecoMET.METFilters.eeBadScFilter_cfi import * eeBadScFilter.taggingMode = cms.bool(True) primaryVertexFilter = cms.EDFilter( "GoodVertexFilter", vertexCollection=cms.InputTag('offlinePrimaryVertices'), minimumNDOF=cms.uint32(4), maxAbsZ=cms.double(15), maxd0=cms.double(2), filter=cms.bool(False)) from CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi import * HBHENoiseFilterResultProducer.minZeros = cms.int32(99999) from RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi import * EcalDeadCellTriggerPrimitiveFilter.taggingMode = cms.bool(True) ggMETFiltersSequence = cms.Sequence( CSCTightHaloFilter * HBHENoiseFilterResultProducer * primaryVertexFilter * eeBadScFilter * EcalDeadCellTriggerPrimitiveFilter)
hasJet = cms.string("hasOverlaps('any')"), hasJetNoPU = cms.string("hasOverlaps('anyNoPU')"), ), tagVariables = cms.PSet( pt = cms.string("pt"), eta = cms.string("eta"), ), tagFlags = cms.PSet(), isMC = cms.bool(False), addRunLumiInfo = cms.bool(True), ) process.tpTreeElElOnePair = process.tpTreeElEl.clone(arbitration = "OnePair") process.tpTreeMuMuOnePair = process.tpTreeMuMu.clone(arbitration = "OnePair") process.fElEl = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("zElEl"), minNumber = cms.uint32(1)) process.fMuMu = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("zMuMu"), minNumber = cms.uint32(1)) process.tnpSimpleSequenceElEl = cms.Path( process.reco + process.tagElectrons * process.varsElectrons * process.zElEl * process.fElEl + process.tpTreeElEl + process.tpTreeElElOnePair ) process.tnpSimpleSequenceMuMu = cms.Path( process.reco + process.tagMuons * process.varsMuons *
cms.PSet( record = cms.string( 'SiStripBadChannelRcd' ), # bad components from O2O tag = cms.string( '' ) ) ) # Clusterizer # import RecoLocalTracker.SiStripClusterizer.SiStripClusterizer_cfi ZeroBiasClusterizer = cms.PSet( Algorithm = cms.string('ThreeThresholdAlgorithm'), ChannelThreshold = cms.double(2.0), SeedThreshold = cms.double(3.0), ClusterThreshold = cms.double(5.0), MaxSequentialHoles = cms.uint32(0), MaxSequentialBad = cms.uint32(1), MaxAdjacentBad = cms.uint32(0), QualityLabel = cms.string('unbiased'), RemoveApvShots = cms.bool(True) ) calZeroBiasClusters = RecoLocalTracker.SiStripClusterizer.SiStripClusterizer_cfi.siStripClusters.clone() calZeroBiasClusters.Clusterizer = ZeroBiasClusterizer # Not persistent collections needed by the filters in the AlCaReco DQM from DPGAnalysis.SiStripTools.eventwithhistoryproducerfroml1abc_cfi import * from DPGAnalysis.SiStripTools.apvcyclephaseproducerfroml1tsDB_cfi import * # SiStripQuality (only to test the different data labels)#
import FWCore.ParameterSet.Config as cms PFJetParameters = cms.PSet( src=cms.InputTag('particleFlow'), srcPVs=cms.InputTag(''), jetType=cms.string('PFJet'), jetPtMin=cms.double(5.0), inputEMin=cms.double(0.0), inputEtMin=cms.double(0.0), doPVCorrection=cms.bool(False), # pileup with offset correction doPUOffsetCorr=cms.bool(False), # if pileup is false, these are not read: #nSigmaPU = cms.double(1.0), #radiusPU = cms.double(0.5), # fastjet-style pileup doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(False), doAreaDiskApprox=cms.bool(False), Active_Area_Repeats=cms.int32(1), GhostArea=cms.double(0.01), Ghost_EtaMax=cms.double(5.0), Rho_EtaMax=cms.double(4.4), voronoiRfact=cms.double(-0.9), useDeterministicSeed=cms.bool(True), minSeed=cms.uint32(14327), applyWeight=cms.bool(False))
eventAutoFlushCompressedSize=cms.untracked.int32(20971520), fileName=cms.untracked.string('file:output.root'), outputCommands=process.RAWSIMEventContent.outputCommands, splitLevel=cms.untracked.int32(0)) # Additional output definition # Other statements process.XMLFromDBSource.label = cms.string("Extended") process.genstepfilter.triggerConditions = cms.vstring("generation_step") from Configuration.AlCa.GlobalTag import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, '102X_upgrade2018_realistic_v11', '') process.gencount = cms.EDFilter("CandViewCountFilter", minNumber=cms.uint32(1), src=cms.InputTag("genfilter")) process.generator = cms.EDFilter( "Pythia8HadronizerFilter", PythiaParameters=cms.PSet( parameterSets=cms.vstring('pythia8CommonSettings', 'pythia8CP5Settings', 'pythia8PSweightsSettings', 'pythia8PowhegEmissionVetoSettings', 'processParameters'), processParameters=cms.vstring( 'POWHEG:nFinal = 1', 'ParticleDecays:limitTau0= off', '25:m0 =125', '25:addChannel = 1 1.0 102 4900101 -4900101', '25:0:onMode=0', '25:1:onMode=0', '25:2:onMode=0', '25:3:onMode=0', '25:4:onMode=0', '25:5:onMode=0', '25:6:onMode=0', '25:7:onMode=0', '25:8:onMode=0',
rawTag = cms.InputTag("hltHcalCalibrationRaw") rawTagUntracked = cms.untracked.InputTag("hltHcalCalibrationRaw") process.essourceSev = cms.ESSource( "EmptyESSource", recordName = cms.string("HcalSeverityLevelComputerRcd"), firstValid = cms.vuint32(1), iovIsRunNotTime = cms.bool(True) ) process.emulTPDigis = \ process.simHcalTriggerPrimitiveDigis.clone() process.emulTPDigis.inputLabel = \ cms.VInputTag("hcalDigis", 'hcalDigis') process.emulTPDigis.FrontEndFormatError = \ cms.bool(True) process.HcalTPGCoderULUT.LUTGenerationMode = cms.bool(False) process.emulTPDigis.FG_threshold = cms.uint32(2) process.emulTPDigis.InputTagFEDRaw = rawTag process.l1GtUnpack.DaqGtInputTag = rawTag process.hbhereco = process.hbheprereco.clone() #------------------------------------- # Hcal DQM Tasks and Clients import #------------------------------------- process.load("DQM.HcalTasks.PedestalTask") process.load('DQM.HcalTasks.RawTask') process.load("DQM.HcalTasks.LaserTask") process.load("DQM.HcalTasks.LEDTask") process.load("DQM.HcalTasks.UMNioTask") process.load('DQM.HcalTasks.HcalOnlineHarvesting') process.load("DQM.HcalTasks.HFRaddamTask") process.load('DQM.HcalTasks.QIE11Task')
EfficiencyBinningSpecification = cms.PSet( UnbinnedVariables=cms.vstring("mass"), BinnedVariables=cms.PSet(EfficiencyBins), BinToPDFmap=cms.vstring(PDFName)) mcTruthModules = cms.PSet() ############################################################################################ process.GsfElectronToId = cms.EDAnalyzer( "TagProbeFitTreeAnalyzer", InputFileNames=cms.vstring(InputFileName), InputDirectoryName=cms.string("tnpAna"), InputTreeName=cms.string("TaPTree"), OutputFileName=cms.string(OutputFilePrefix + "EleVeto.root"), NumCPU=cms.uint32(1), SaveWorkspace=cms.bool(False), doCutAndCount=cms.bool(False), floatShapeParameters=cms.bool(True), binnedFit=cms.bool(True), binsForFit=cms.uint32(40), # 20-200 EB #binsForFit = cms.uint32(30), # 200-350 EB #binsForFit = cms.uint32(20), # >=350 EB #binsForFit = cms.uint32(40), # 20-180 EE #binsForFit = cms.uint32(30), # >=180 EE # defines all the real variables of the probes available in the input tree and intended for use in the efficiencies Variables=cms.PSet( mass=cms.vstring("Tag-Probe Mass", "70.0", "110.0", "GeV/c^{2}"), probe_pt=cms.vstring("Probe E_{T}", "0", "500", "GeV/c"), probe_absEta=cms.vstring("Probe #eta", "0", "2.5", ""), ),
commonGenTauDecayIDPSet = cms.PSet(momPDGID=cms.vint32(A_PDGID), chargedHadronPTMin=cms.double(0.0), neutralHadronPTMin=cms.double(0.0), chargedLeptonPTMin=cms.double(0.0), totalPTMin=cms.double(0.0)) #define a parameter set for the W-->munu selector WMuNuPSet = commonGenTauDecayIDPSet.clone() WMuNuPSet.momPDGID = cms.vint32(W_PDGID) #only proceed if event is a true W-->munu event process.genWMuNuSelector = cms.EDFilter( 'GenObjectProducer', genParticleTag=cms.InputTag('genParticles'), absMatchPDGIDs=cms.vuint32(MU_PDGID), sisterAbsMatchPDGID=cms.uint32(NUMU_PDGID), genTauDecayIDPSet=WMuNuPSet, primaryTauDecayType=cms.uint32(TAU_ALL), sisterTauDecayType=cms.uint32(TAU_ALL), primaryTauPTRank=cms.int32(ANY_PT_RANK), primaryTauHadronicDecayType=cms.int32(TAU_ALL_HAD), sisterHadronicDecayType=cms.int32(TAU_ALL_HAD), primaryTauAbsEtaMax=cms.double(-1.0), primaryTauPTMin=cms.double(-1.0), countSister=cms.bool(False), applyPTCuts=cms.bool(False), countKShort=cms.bool(True), minNumGenObjectsToPassFilter=cms.uint32(1), makeAllCollections=cms.bool(False)) #require event to fire IsoMu24_eta2p1
import FWCore.ParameterSet.Config as cms # link to cards: # https://github.com/OlivierBondu/genproductions/tree/ed5057598b9fbf246741829603162f1bc6700f7d/bin/MadGraph5_aMCatNLO/cards/production/13TeV/exo_diboson/Spin-0/Radion_GF_HH externalLHEProducer = cms.EDProducer( "ExternalLHEProducer", args=cms.vstring( '/cvmfs/cms.cern.ch/phys_generator/gridpacks/slc6_amd64_gcc481/13TeV/madgraph/V5_2.3.2.2/Radion_GF_HH/Radion_GF_HH_M650_narrow/v1/Radion_GF_HH_M650_narrow_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')) from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * from Configuration.Generator.Pythia8PowhegEmissionVetoSettings_cfi import * generator = cms.EDFilter( "Pythia8HadronizerFilter", 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.), PythiaParameters=cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, processParameters=cms.vstring(
input = cms.untracked.int32(<number_of_events>) ) # -- Trajectory producer process.load("RecoTracker.TrackProducer.TrackRefitters_cff") process.TrackRefitter.src = 'generalTracks' process.TrackRefitter.NavigationSchool = "" # -- RecHit production process.load("RecoLocalTracker.SiPixelRecHits.SiPixelRecHits_cfi") process.PixelFilter = cms.EDFilter("TriggerResultsFilter", triggerConditions = cms.vstring('HLT_ZeroBias_*/1'), hltResults = cms.InputTag( "TriggerResults", "", "HLT" ), l1tResults = cms.InputTag( "" ), daqPartitions = cms.uint32( 1 ), l1tIgnoreMask = cms.bool( False ), l1techIgnorePrescales = cms.bool( True ), throw = cms.bool( True ) ) process.PixelTree = cms.EDAnalyzer( "PixelTree", verbose = cms.untracked.int32(0), rootFileName = cms.untracked.string('<output_root_file_name>'), globalTag = process.GlobalTag.globaltag, dumpAllEvents = cms.untracked.int32(0), PrimaryVertexCollectionLabel = cms.untracked.InputTag('offlinePrimaryVertices'), muonCollectionLabel = cms.untracked.InputTag('muons'), trajectoryInputLabel = cms.untracked.InputTag('TrackRefitter::RECO'), trackCollectionLabel = cms.untracked.InputTag('generalTracks'),
maxdR_matching=cms.double(0.1), ## for the output selected collection (tag + all compatible in dZ) # difference of the vz of the trigger muon with selected muon dzForCleaning_wrtTrgMuon=cms.double(-1), # initial value: 1.8 # selection for the selected muon selmu_ptMin=cms.double(0.5), selmu_absEtaMax=cms.double(2.4), selmu_softMuonsOnly=cms.bool(False), # note used anymore HLTPaths=cms.vstring(Path), #L1seeds=cms.vstring(Seed), ) #cuts minimun number in B both mu and e, min number of trg, dz muon, dz and dr track, countTrgMuons = cms.EDFilter("PATCandViewCountFilter", minNumber=cms.uint32(1), maxNumber=cms.uint32(999999), src=cms.InputTag("muonTrgSelector", "trgMuons")) muonBParkTable = cms.EDProducer( "SimpleCandidateFlatTableProducer", src=cms.InputTag("muonTrgSelector:SelectedMuons"), cut=cms.string(""), #we should not filter on cross linked collections name=cms.string("Muon"), doc=cms.string("slimmedMuons for BPark after basic selection"), singleton=cms.bool(False), # the number of entries is variable extension=cms.bool(False), # this is the main table for the muons variables=cms.PSet( CandVars, ptErr=Var("bestTrack().ptError()", float,
#process.dqmSaver.saveByMinute = cms.untracked.int32(-1) ###### Output file ###### #process.Output = cms.OutputModule("PoolOutputModule", # fileName = cms.untracked.string( "/tmp/dinardo/BeamPixelResults.root" ), # outputCommands = cms.untracked.vstring( "drop *", # "keep *_*_*_BeamPixel")) ### @@@@@@ Un-comment when running locally @@@@@@ ### #---------------------------- # pixelVertexDQM Configuration #---------------------------- process.pixelVertexDQM = cms.EDAnalyzer( "Vx3DHLTAnalyzer", vertexCollection=cms.InputTag("pixelVertices"), debugMode=cms.bool(True), nLumiReset=cms.uint32(1), dataFromFit=cms.bool(True), minNentries=cms.uint32(35), # If the histogram has at least "minNentries" then extract Mean and RMS, # or, if we are performing the fit, the number of vertices must be greater # than minNentries otherwise it waits for other nLumiReset xRange=cms.double(2.0), xStep=cms.double(0.001), yRange=cms.double(2.0), yStep=cms.double(0.001), zRange=cms.double(30.0), zStep=cms.double(0.05), VxErrCorr=cms.double(1.5), fileName=cms.string( "/nfshome0/yumiceva/BeamMonitorDQM/BeamPixelResults.txt")) if process.dqmSaver.producer.value() is "Playback":
#process.secTriplets.OrderedHitsFactoryPSet.GeneratorPSet.maxElement = cms.uint32(2000000) process.load("DPGAnalysis.SiStripTools.largesipixelclusterevents_cfi") process.largeSiPixelClusterEvents.absoluteThreshold = cms.untracked.int32(3000) process.largeSiPixelClusterEvents.moduleThreshold = cms.untracked.int32(10000) process.load("DPGAnalysis.SiStripTools.sipixelclustermultiplicityprod_cfi") process.load("DPGAnalysis.SiStripTools.sistripclustermultiplicityprod_cfi") process.seqMultProd = cms.Sequence(process.spclustermultprod+process.ssclustermultprod) process.load("DPGAnalysis.SiStripTools.multiplicitycorr_cfi") process.multiplicitycorr.correlationConfigurations = cms.VPSet( cms.PSet(xMultiplicityMap = cms.InputTag("ssclustermultprod"), xDetSelection = cms.uint32(0), xDetLabel = cms.string("TK"), xBins = cms.uint32(1000), xMax=cms.double(50000), yMultiplicityMap = cms.InputTag("spclustermultprod"), yDetSelection = cms.uint32(0), yDetLabel = cms.string("Pixel"), yBins = cms.uint32(1000), yMax=cms.double(20000), rBins = cms.uint32(200), scaleFactor =cms.untracked.double(5.)) ) process.load("DPGAnalysis.SiStripTools.seedmultiplicitymonitor_cfi") process.seedmultiplicitymonitor.multiplicityCorrelations = cms.VPSet( cms.PSet(multiplicityMap = cms.InputTag("ssclustermultprod"), detSelection = cms.uint32(0), detLabel = cms.string("TK"), nBins = cms.uint32(1000), nBinsEta = cms.uint32(100), maxValue=cms.double(100000) ), cms.PSet(multiplicityMap = cms.InputTag("spclustermultprod"), detSelection = cms.uint32(0), detLabel = cms.string("Pixel"), nBins = cms.uint32(1000), nBinsEta = cms.uint32(100), maxValue=cms.double(20000) ) )
* process.siPixelClusterShapeCachePreSplitting * process.recopixelvertexing) # triggerName for selecting pv for DIP publication, no wildcard needed here # it will pick all triggers which has these strings in theri name process.dqmBeamMonitor.jetTrigger = cms.untracked.vstring( "HLT_PAZeroBias_v", "HLT_ZeroBias_v", "HLT_QuadJet", "HLT_ZeroBias_", "HLT_HI") # for HI only: select events based on the pixel cluster multiplicity if (process.runType.getRunType() == process.runType.hi_run): import HLTrigger.special.hltPixelActivityFilter_cfi process.multFilter = HLTrigger.special.hltPixelActivityFilter_cfi.hltPixelActivityFilter.clone( inputTag = cms.InputTag('siPixelClustersPreSplitting'), minClusters = cms.uint32(150), maxClusters = cms.uint32(50000) # was 10000 ) process.filter_step = cms.Sequence( process.siPixelDigis * process.siPixelClustersPreSplitting * process.multFilter ) process.dqmBeamMonitor.hltResults = cms.InputTag("TriggerResults","","HLT") #--------- # Upload BeamSpotOnlineObject (LegacyRcd) to CondDB process.OnlineDBOutputService = cms.Service("OnlineDBOutputService", DBParameters = cms.PSet(
RegionPSet=RegionPsetFomBeamSpotBlock.RegionPSet.clone( ptMin=0.2, originRadius=0.02, nSigmaZ=4.0)), SeedMergerPSet=cms.PSet( layerList=cms.PSet( refToPSet_=cms.string("PixelSeedMergerQuadruplets")), addRemainingTriplets=cms.bool(False), mergeTriplets=cms.bool(True), ttrhBuilderLabel=cms.string('PixelTTRHBuilderWithoutAngle'))) lowPtQuadStepSeeds.OrderedHitsFactoryPSet.SeedingLayers = 'lowPtQuadStepSeedLayers' lowPtQuadStepSeeds.SeedCreatorPSet.SimpleMagneticField = '' from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeHitFilterESProducer_cfi import * import RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi lowPtQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.SeedComparitorPSet = RecoPixelVertexing.PixelLowPtUtilities.LowPtClusterShapeSeedComparitor_cfi.LowPtClusterShapeSeedComparitor lowPtQuadStepSeeds.ClusterCheckPSet.doClusterCheck = cms.bool(False) lowPtQuadStepSeeds.OrderedHitsFactoryPSet.GeneratorPSet.maxElement = cms.uint32( 0) # QUALITY CUTS DURING TRACK BUILDING import TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff lowPtQuadStepStandardTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits=3, minPt=0.075) from RecoPixelVertexing.PixelLowPtUtilities.ClusterShapeTrajectoryFilter_cfi import * # Composite filter lowPtQuadStepTrajectoryFilter = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CompositeTrajectoryFilter_block.clone( filters=[ cms.PSet( refToPSet_=cms.string('lowPtQuadStepStandardTrajectoryFilter')), cms.PSet(refToPSet_=cms.string('ClusterShapeTrajectoryFilter')) ])
process.recoCSVLineAB = cms.EDAnalyzer('RecoToCSVWithABLinesAnalyzer', recoId=cms.string(reco_number), fill_file_name=cms.string(csv_filename)) process.recoMultiCSV = cms.EDAnalyzer('RecoMultiToCSVAnalyzer', recoId=cms.string(reco_number), fill_name=cms.string(csv_filename)) process.recoCSVCombined = cms.EDAnalyzer( 'RecoCSVCombinedSingleMulti', recoId=cms.string(reco_number), fill_file_name=cms.string(csv_filename)) process.recoBinaryCombined = cms.EDAnalyzer( 'RecoBinaryCombinedSingleMulti', recoId=cms.uint32(int(reco_number)), fill_file_name=cms.string(bin_filename)) process.p = cms.Path( process.recoBinaryCombined # process.recoMultiCSV # process.recoCSVLineAB # process.recoCSVCombined # process.recoLogger # process.demo # process.recoHist # process.recoToFlatRoot # process.recoCSV )
# realistic upgrade scenario: # one ALCT finder and two CLCT finders per ME11 # with additional logic for A/CLCT matching with ME1a unganged # smartME1aME1b=t, gangedME1a=t # the previous case with ME1a still being ganged # Note: gangedME1a has effect only if smartME1aME1b=t smartME1aME1b=cms.bool(False), gangedME1a=cms.bool(True), # flags to optionally disable finding stubs in ME42 or ME1a disableME1a=cms.bool(False), disableME42=cms.bool(False), ), # Parameters for ALCT processors: old MC studies alctParamOldMC=cms.PSet(alctFifoTbins=cms.uint32(16), alctFifoPretrig=cms.uint32(10), alctDriftDelay=cms.uint32(3), alctNplanesHitPretrig=cms.uint32(2), alctNplanesHitPattern=cms.uint32(4), alctNplanesHitAccelPretrig=cms.uint32(2), alctNplanesHitAccelPattern=cms.uint32(4), alctTrigMode=cms.uint32(3), alctAccelMode=cms.uint32(1), alctL1aWindowWidth=cms.uint32(5), verbosity=cms.int32(0)), # Parameters for ALCT processors: MTCC-II alctParamMTCC=cms.PSet(alctFifoTbins=cms.uint32(16), alctFifoPretrig=cms.uint32(10), alctDriftDelay=cms.uint32(3),
process.muonCSCDigis.InputObjects = cms.InputTag("rawDataCollector") process.muonDTDigis.inputLabel = cms.InputTag("rawDataCollector") process.muonRPCDigis.InputLabel = cms.InputTag("rawDataCollector") process.scalersRawToDigi.scalersInputTag = cms.InputTag("rawDataCollector") process.siPixelDigis.InputLabel = cms.InputTag("rawDataCollector") process.siStripDigis.ProductLabel = cms.InputTag("rawDataCollector") #---------------------------- # pixelVertexDQM Config #---------------------------- process.pixelVertexDQM = DQMEDAnalyzer('Vx3DHLTAnalyzer', vertexCollection = cms.untracked.InputTag("pixelVertices"), pixelHitCollection = cms.untracked.InputTag("siPixelRecHitsPreSplitting"), debugMode = cms.bool(True), nLumiFit = cms.uint32(2), maxLumiIntegration = cms.uint32(15), nLumiXaxisRange = cms.uint32(5000), dataFromFit = cms.bool(True), minNentries = cms.uint32(20), # If the histogram has at least "minNentries" then extract Mean and RMS, # or, if we are performing the fit, the number of vertices must be greater # than minNentries otherwise it waits for other nLumiFit xRange = cms.double(0.8), xStep = cms.double(0.001), yRange = cms.double(0.8), yStep = cms.double(0.001), zRange = cms.double(30.0), zStep = cms.double(0.04), VxErrCorr = cms.double(1.2), # Keep checking this with later release minVxDoF = cms.double(10.0),
timetype = cms.string('runnumber'), interval = cms.uint64(1) ) process.PoolDBOutputService = cms.Service("PoolDBOutputService", process.CondDB, timetype = cms.untracked.string('runnumber'), toPut = cms.VPSet(cms.PSet( # Thresholds record = cms.string('ESThresholdsRcd'), tag = cms.string('ESThresholds_LG') ))) process.ecalModule = cms.EDAnalyzer("StoreESCondition", logfile = cms.string('./logfile.log'), gain = cms.uint32(1), toPut = cms.VPSet(cms.PSet( # Thresholds conditionType = cms.untracked.string('ESThresholds'), since = cms.untracked.uint32(1), inputFile = cms.untracked.string('CondTools/Ecal/test/preshower/ESThresholds_LG.txt') ))) process.p = cms.Path(process.ecalModule)
# https://github.com/cms-sw/cmssw/blob/CMSSW_8_0_X/RecoJets/Configuration/python/GenJetParticles_cff.py # https://github.com/cms-sw/cmssw/blob/CMSSW_8_0_X/RecoMET/Configuration/python/GenMETParticles_cff.py tmpGenParticlesForJetsNoNu = cms.EDProducer( "InputGenJetsParticleSelector", src=cms.InputTag("tmpGenParticles"), ignoreParticleIDs=cms.vuint32(1000022, 1000012, 1000014, 1000016, 2000012, 2000014, 2000016, 1000039, 5100039, 4000012, 4000014, 4000016, 9900012, 9900014, 9900016, 39, 12, 14, 16), partonicFinalState=cms.bool(False), excludeResonances=cms.bool(False), excludeFromResonancePids=cms.vuint32(12, 13, 14, 16), tausAsJets=cms.bool(False)) # https://github.com/cms-sw/cmssw/blob/CMSSW_8_0_X/RecoJets/JetProducers/python/AnomalousCellParameters_cfi.py AnomalousCellParameters = cms.PSet(maxBadEcalCells=cms.uint32(9999999), maxRecoveredEcalCells=cms.uint32(9999999), maxProblematicEcalCells=cms.uint32(9999999), maxBadHcalCells=cms.uint32(9999999), maxRecoveredHcalCells=cms.uint32(9999999), maxProblematicHcalCells=cms.uint32(9999999)) # https://github.com/cms-sw/cmssw/blob/CMSSW_8_0_X/RecoJets/JetProducers/python/GenJetParameters_cfi.py GenJetParameters = cms.PSet( src=cms.InputTag("tmpGenParticlesForJetsNoNu"), srcPVs=cms.InputTag(''), jetType=cms.string('GenJet'), jetPtMin=cms.double(3.0), inputEtMin=cms.double(0.0), inputEMin=cms.double(0.0), doPVCorrection=cms.bool(False),
import FWCore.ParameterSet.Config as cms from DQMOffline.Trigger.topMonitoring_cfi import topMonitoring hltTOPmonitoring = topMonitoring.clone() hltTOPmonitoring.FolderName = cms.string('HLT/TOP/default/') hltTOPmonitoring.histoPSet.lsPSet = cms.PSet( nbins=cms.uint32(250), xmin=cms.double(0.), xmax=cms.double(2500.), ) hltTOPmonitoring.histoPSet.metPSet = cms.PSet( nbins=cms.uint32(30), xmin=cms.double(0), xmax=cms.double(300), ) hltTOPmonitoring.histoPSet.ptPSet = cms.PSet( nbins=cms.uint32(60), xmin=cms.double(0), xmax=cms.double(300), ) hltTOPmonitoring.histoPSet.lsPSet = cms.PSet(nbins=cms.uint32(2500), ) hltTOPmonitoring.histoPSet.phiPSet = cms.PSet( nbins=cms.uint32(32), xmin=cms.double(-3.2), xmax=cms.double(3.2), ) hltTOPmonitoring.histoPSet.etaPSet = cms.PSet( nbins=cms.uint32(24), xmin=cms.double(-2.4), xmax=cms.double(2.4),
process.Options = cms.PSet( ## Name of the tree on which perform th training TreeName=cms.string("chs"), ## Name for ggH signal --> match what is written in the sample list file SignalggHName=cms.string("RSGWW1000"), ## Name for ggH signal --> match what is written in the sample list file SignalqqHName=cms.string(""), ## string which use tree branches to re-weight the events EventWeight=cms.string(""), ## 0 use both ggH and qqH as signal, 1 use only ggH as signal, 2 use only qqH as signal useTypeOfSignal=cms.uint32(0), ## string which is used in the TMVATraining class to define a cut to be applied on the events PreselectionCutType=cms.string("basicJetsCutCSA14"), ## luminosity in order to compute signal and bk expectations Lumi=cms.double(19297), ## Lepton Type: Muon, Electron ,EleMu and Jets (fully hadronic) LeptonType=cms.string("Jets"), ## output directory for root and weight file outputPlotDirectory=cms.string("TMVATrainingPlots_CHS_highPT_lowPU/"), ##input file and variables InputInformationParam=cms.VPSet(
'&& quality(\"highPurity\")')) # dimuon = Onia2MUMU from HeavyFlavorAnalysis.Onia2MuMu.onia2MuMuPAT_cfi import * onia2MuMuPAT.muons = cms.InputTag('oniaSelectedMuons') onia2MuMuPAT.primaryVertexTag = cms.InputTag('offlinePrimaryVertices') onia2MuMuPAT.beamSpotTag = cms.InputTag('offlineBeamSpot') onia2MuMuPAT.dimuonSelection = cms.string( "0.2 < mass && abs(daughter('muon1').innerTrack.dz - daughter('muon2').innerTrack.dz) < 25" ) onia2MuMuPAT.addMCTruth = cms.bool(False) onia2MuMuPATCounter = cms.EDFilter('CandViewCountFilter', src=cms.InputTag('onia2MuMuPAT'), minNumber=cms.uint32(1), filter=cms.bool(True)) # make photon candidate conversions for P-wave studies from HeavyFlavorAnalysis.Onia2MuMu.OniaPhotonConversionProducer_cfi import PhotonCandidates as oniaPhotonCandidates # add v0 with tracks embed from HeavyFlavorAnalysis.Onia2MuMu.OniaAddV0TracksProducer_cfi import * # Pick branches you want to keep BPHSkim_EventContent = cms.PSet(outputCommands=cms.untracked.vstring( 'drop *', 'keep recoVertexs_offlinePrimaryVertices_*_*', 'keep *_offlineBeamSpot_*_*', 'keep *_TriggerResults_*_HLT', 'keep *_gtDigis_*_RECO', 'keep *_oniaSelectedTracks_*_*', 'keep *_oniaPhotonCandidates_*_*', 'keep *_onia2MuMuPAT_*_*', 'keep *_oniaV0Tracks_*_*', 'keep PileupSummaryInfos_*_*_*'))
process.puppi.useExistingWeights = True process.puppi.candName = cms.InputTag('packedPFCandidates') process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices') process.ak8PFJetsCHS = ak8PFJetsCHS.clone( src = 'puppi', jetPtMin = 100.0 ) process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'puppi', jetPtMin = 100.0 ) process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone() process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'puppi', jetPtMin = 100.0 ) process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone() process.NjettinessAK8 = cms.EDProducer("NjettinessAdder", src = cms.InputTag("ak8PFJetsCHS"), Njets = cms.vuint32(1, 2, 3, 4), # variables for measure definition : measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure beta = cms.double(1.0), # CMS default is 1 R0 = cms.double( 0.8 ), # CMS default is jet cone size Rcutoff = cms.double( 999.0), # not used by default # variables for axes definition : axesDefinition = cms.uint32( 6 ), # CMS default is 1-pass KT axes nPass = cms.int32(0), # not used by default akAxesR0 = cms.double(-999.0) # not used by default ) process.substructureSequence = cms.Sequence() process.substructureSequence+=process.puppi process.substructureSequence+=process.ak8PFJetsCHS process.substructureSequence+=process.NjettinessAK8 process.substructureSequence+=process.ak8PFJetsCHSPruned process.substructureSequence+=process.ak8PFJetsCHSPrunedMass
jetCoreRegionalStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( MeasurementTrackerName='', trajectoryFilter=cms.PSet( refToPSet_=cms.string('jetCoreRegionalStepTrajectoryFilter')), #clustersToSkip = cms.InputTag('jetCoreRegionalStepClusters'), maxCand=50, estimator=cms.string('jetCoreRegionalStepChi2Est'), maxDPhiForLooperReconstruction=cms.double(2.0), maxPtForLooperReconstruction=cms.double(0.7)) # MAKING OF TRACK CANDIDATES import RecoTracker.CkfPattern.CkfTrackCandidates_cfi jetCoreRegionalStepTrackCandidates = RecoTracker.CkfPattern.CkfTrackCandidates_cfi.ckfTrackCandidates.clone( src=cms.InputTag('jetCoreRegionalStepSeeds'), maxSeedsBeforeCleaning=cms.uint32(10000), TrajectoryBuilderPSet=cms.PSet( refToPSet_=cms.string('jetCoreRegionalStepTrajectoryBuilder')), NavigationSchool=cms.string('SimpleNavigationSchool'), ### these two parameters are relevant only for the CachingSeedCleanerBySharedInput #numHitsForSeedCleaner = cms.int32(50), #onlyPixelHitsForSeedCleaner = cms.bool(True), ) # TRACK FITTING import RecoTracker.TrackProducer.TrackProducer_cfi jetCoreRegionalStepTracks = RecoTracker.TrackProducer.TrackProducer_cfi.TrackProducer.clone( AlgorithmName=cms.string('jetCoreRegionalStep'), src='jetCoreRegionalStepTrackCandidates', Fitter=cms.string('FlexibleKFFittingSmoother'))
import FWCore.ParameterSet.Config as cms SiStripSpyEventMatcher = cms.EDFilter( "SiStripSpyEventMatcherModule", FilterNonMatchingEvents = cms.bool(True), MergeData = cms.bool(True), PrimaryEventRawDataTag = cms.InputTag('source'), SpyTotalEventCountersTag = cms.InputTag('SiStripSpyUnpacker','TotalEventCount'), SpyL1ACountersTag = cms.InputTag('SiStripSpyUnpacker','L1ACount'), SpyAPVAddressesTag = cms.InputTag('SiStripSpyDigiConverter','APVAddress'), RawSpyDataTag = cms.InputTag('source'), SpyScopeDigisTag = cms.InputTag('SiStripSpyUnpacker','ScopeRawDigis'), SpyPayloadDigisTag = cms.InputTag('SiStripSpyDigiConverter','Payload'), SpyReorderedDigisTag = cms.InputTag('SiStripSpyDigiConverter','Reordered'), SpyVirginRawDigisTag = cms.InputTag('SiStripSpyDigiConverter','VirginRaw'), SpySource = cms.SecSource( "EmbeddedRootSource", fileNames = cms.untracked.vstring( 'SpyFileNameWhichNeedsToBeSet SiStripSpyEventMatcher.SpySource.fileNames' ), sequential = cms.untracked.bool(True), ), CounterDiffMaxAllowed = cms.uint32(100) )
process.InitialStepPreSplittingTask.remove( process.ak4CaloJetsForTrkPreSplitting) process.InitialStepPreSplittingTask.remove( process.jetsForCoreTrackingPreSplitting) process.InitialStepPreSplittingTask.remove(process.siPixelClusters) process.InitialStepPreSplittingTask.remove(process.siPixelRecHits) process.InitialStepPreSplittingTask.remove(process.MeasurementTrackerEvent) # Redefinition of siPixelClusters: has to be after RecoTracker.IterativeTracking.InitialStepPreSplitting_cff process.load("RecoLocalTracker.SiPixelClusterizer.SiPixelClusterizer_cfi") # Select events based on the pixel cluster multiplicity import HLTrigger.special.hltPixelActivityFilter_cfi process.multFilter = HLTrigger.special.hltPixelActivityFilter_cfi.hltPixelActivityFilter.clone( inputTag=cms.InputTag('siPixelClusters'), minClusters=cms.uint32(1), maxClusters=cms.uint32(50000)) # BaselineValidator Module from EventFilter.SiStripRawToDigi.SiStripDigis_cfi import siStripDigis as _siStripDigis process.siStripDigisNoZS = _siStripDigis.clone() process.siStripDigisNoZS.ProductLabel = cms.InputTag("rawDataCollector") process.SiStripBaselineValidator.srcProcessedRawDigi = cms.InputTag( 'siStripDigisNoZS', 'ZeroSuppressed') from RecoTracker.TkSeedingLayers.PixelLayerTriplets_cfi import * process.PixelLayerTriplets.BPix.HitProducer = cms.string( 'siPixelRecHitsPreSplitting') process.PixelLayerTriplets.FPix.HitProducer = cms.string( 'siPixelRecHitsPreSplitting') from RecoPixelVertexing.PixelTrackFitting.PixelTracks_cff import *