def CMGWPswitchToPFJets(process) : addJetCollection(process,cms.InputTag('newAK7PF'),'AK7','PF', doJTA = True, doBTagging = True, jetCorrLabel = ('AK7PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])), doType1MET = True, genJetCollection=cms.InputTag("ak7GenJets"), doJetID = False ) addJetCollection(process,cms.InputTag('ak5PFJets'),'AK5','PF', doJTA = True, doBTagging = True, jetCorrLabel = ('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])), doType1MET = True, genJetCollection=cms.InputTag("ak5GenJets"), doJetID = False ) process.selectedPatPFParticles.cut = "" from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ), src=cms.InputTag('offlinePrimaryVertices') )
def ReMatchL1(process): from MuonAnalysis.MuonAssociators.patMuonsWithTrigger_8E29_cff import muonMatchHLTL1 process.muonReMatchL1DoubleMuOpen = muonMatchHLTL1.clone( src = cms.InputTag("patMuons"), matched = cms.InputTag("patTriggerMuons"), filterLabels = cms.vstring('hltDoubleMuLevel1PathL1OpenFiltered'), maxDeltaR = cms.double(1.2), maxDeltaEta = cms.double(0.2), fallbackToME1 = cms.bool(True), ) process.patMuonsL1Rematched = cms.EDProducer( "PATTriggerMatchMuonEmbedder", src = cms.InputTag( "patMuons" ), matches = cms.VInputTag(cms.InputTag("muonReMatchL1DoubleMuOpen")) ) process.tagMuons1MuL1Rematched = process.tagMuons1Mu.clone(src = "patMuonsL1Rematched") process.anyProbeMuons.src = "patMuonsL1Rematched" process.tpGlbAny.decay = "tagMuons1MuL1Rematched@+ anyProbeMuons@-" process.tnpSequenceTrigger.replace(process.anyProbeMuons, process.muonReMatchL1DoubleMuOpen * process.patMuonsL1Rematched * ( process.tagMuons1MuL1Rematched + process.anyProbeMuons ) ) if process.histoTrigger.isMC.value(): process.muMcMatchL1Rematched = process.muMcMatch.clone(src = "patMuonsL1Rematched") process.histoTrigger.tagMatches = "muMcMatchL1Rematched" process.histoTrigger.probeMatches = "muMcMatchL1Rematched" process.tnpSequenceTrigger.replace(process.histoTrigger, process.muMcMatchL1Rematched * process.histoTrigger )
def customiseForUncollapsed(process): for producer in producers_by_type(process, "PFClusterProducer"): if producer.seedFinder.thresholdsByDetector[1].detector.value() == 'HCAL_ENDCAP': producer.pfClusterBuilder.recHitEnergyNorms = recHitEnergyNorms2018 producer.seedFinder.thresholdsByDetector = seedFinderThresholdsByDetector2018 producer.initialClusteringStep.thresholdsByDetector = initialClusteringStepThresholdsByDetector2018 producer.pfClusterBuilder.positionCalc.logWeightDenominatorByDetector = logWeightDenominatorByDetector2018 producer.pfClusterBuilder.allCellsPositionCalc.logWeightDenominatorByDetector = logWeightDenominatorByDetector2018 for producer in producers_by_type(process, "PFMultiDepthClusterProducer"): producer.pfClusterBuilder.allCellsPositionCalc.logWeightDenominatorByDetector = logWeightDenominatorByDetector2018_HCAL for producer in producers_by_type(process, "PFRecHitProducer"): if producer.producers[0].name.value() == 'PFHBHERecHitCreator': producer.producers[0].qualityTests[0].cuts = cuts2018 for producer in producers_by_type(process, "CaloTowersCreator"): producer.HcalPhase = cms.int32(1) producer.HESThreshold1 = cms.double(0.1) producer.HESThreshold = cms.double(0.2) producer.HEDThreshold1 = cms.double(0.1) producer.HEDThreshold = cms.double(0.2) #remove collapser from sequence process.hltHbhereco = process.hltHbhePhase1Reco.clone() process.HLTDoLocalHcalSequence = cms.Sequence( process.hltHcalDigis + process.hltHbhereco + process.hltHfprereco + process.hltHfreco + process.hltHoreco ) process.HLTStoppedHSCPLocalHcalReco = cms.Sequence( process.hltHcalDigis + process.hltHbhereco ) return process
def makePuppiesFromMiniAOD( process ): process.load('CommonTools.PileupAlgos.Puppi_cff') process.puppi.candName = cms.InputTag('packedPFCandidates') process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices') # kind of ugly, is there a better way to do this? process.pfNoLepPUPPI = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 && abs(pdgId) != 15")) process.pfLeptonsPUPPET = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) == 13 || abs(pdgId) == 11 || abs(pdgId) == 15")) process.puppiNoLep = process.puppi.clone() process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI') process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET')) ## puppi met process.puppiForMET = cms.EDProducer("PuppiPhoton", candName = cms.InputTag('packedPFCandidates'), puppiCandName = cms.InputTag('puppi'), photonName = cms.InputTag('slimmedPhotons'), photonId = cms.InputTag("egmPhotonIDs:cutBasedPhotonID_PHYS14_PU20bx25_V2p1-standalone-loose"), pt = cms.double(10), useRefs = cms.bool(True), dRMatch = cms.vdouble(10,10,10,10), pdgids = cms.vint32 (22,11,211,130), weight = cms.double(1.), useValueMap = cms.bool(False), weightsName = cms.InputTag('puppi'), ) process.puppiForMET.puppiCandName = 'puppiMerged'
def kinAxis(apt1, apt2, am1, am2) : return cms.PSet( pt1 = cms.double( apt1 ), pt2 = cms.double( apt2 ), m1 = cms.double( am1 ), m2 = cms.double( am2 ) )
def MakeEventSelection( invMassMethod, _from, _to, GenMatch, _JetVeto, _VetoMoreThan2, _MET, _MT) : method = -1 if invMassMethod == "Momentum" : method = 0 elif invMassMethod == "GSF" : method = 1 elif invMassMethod == "GSFOut" : method = 2 elif invMassMethod == "SC" : method = 3 elif invMassMethod == "Seed" : method = 4 elif invMassMethod == "CTF" : method = 5 ret = cms.PSet( InvMassMethod=cms.int32(method), InvMassMin=cms.double(_from), InvMassMax=cms.double(_to), MET=cms.double(_MET), MT=cms.double(_MT), ElectronsShouldMatch=cms.bool(GenMatch), JetVeto=cms.bool(_JetVeto), VetoMoreThan2Elecs=cms.bool(_VetoMoreThan2) ) return ret
def customise_Reco(process): #lowering HO threshold with SiPM for prod in process.particleFlowRecHitHO.producers: prod.qualityTests = cms.VPSet( cms.PSet( name = cms.string("PFRecHitQTestThreshold"), threshold = cms.double(0.05) # new threshold for SiPM HO ), cms.PSet( name = cms.string("PFRecHitQTestHCALChannel"), maxSeverities = cms.vint32(11), cleaningThresholds = cms.vdouble(0.0), flags = cms.vstring('Standard') ) ) #Lower Thresholds also for Clusters!!! for p in process.particleFlowClusterHO.seedFinder.thresholdsByDetector: p.seedingThreshold = cms.double(0.08) for p in process.particleFlowClusterHO.initialClusteringStep.thresholdsByDetector: p.gatheringThreshold = cms.double(0.05) for p in process.particleFlowClusterHO.pfClusterBuilder.recHitEnergyNorms: p.recHitEnergyNorm = cms.double(0.05) process.particleFlowClusterHO.pfClusterBuilder.positionCalc.logWeightDenominator = cms.double(0.05) process.particleFlowClusterHO.pfClusterBuilder.allCellsPositionCalc.logWeightDenominator = cms.double(0.05) return process
def addRhoVariables(process, seq, eleTag="gsfElectrons", muTag="muons", pfNoPUTag="pfNoPileUp"): process.kt6PFJets.doRhoFastjet = cms.bool(True) process.kt6PFJets.doAreaFastjet = cms.bool(True) process.kt6PFJets.Rho_EtaMax = cms.double(4.4) process.kt6PFJetsForIso = process.kt6PFJets.clone(Rho_EtaMax=cms.double(2.5), Ghost_EtaMax=cms.double(2.5)) process.kt6PFJetsNoPU = process.kt6PFJets.clone(src=pfNoPUTag) process.kt6PFJetsForIsoNoPU = process.kt6PFJetsForIso.clone(src=pfNoPUTag) # Re-cluster jets w/ pfNoPileUp process.ak5PFJetsNoPU = process.ak5PFJets.clone(src=pfNoPUTag) process.load("WWAnalysis.Tools.rhoValueMapProducer_cfi") process.rhoMu = process.rhoValueMapProducer.clone( rhoTag=cms.untracked.InputTag("kt6PFJetsForIso", "rho", process.name_()), leptonTag=muTag ) process.rhoEl = process.rhoMu.clone(leptonTag=eleTag) process.rhoMuNoPU = process.rhoValueMapProducer.clone( rhoTag=cms.untracked.InputTag("kt6PFJetsForIsoNoPU", "rho", process.name_()), leptonTag=muTag ) process.rhoElNoPU = process.rhoMuNoPU.clone(leptonTag=eleTag) process.valueMaps = cms.Sequence(process.rhoMu + process.rhoEl + process.rhoMuNoPU + process.rhoElNoPU) seq += ( process.ak5PFJets + process.kt6PFJets + process.kt6PFJetsForIso + process.pfPileUp * process.pfNoPileUp * (process.ak5PFJetsNoPU + process.kt6PFJetsNoPU + process.kt6PFJetsForIsoNoPU) * process.valueMaps )
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 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 defineAnalysis(process,castorDir="",reRunRho=False) : # our MET producer process.ClusteredPFMetProducer = ClusteredPFMetProducer.clone() # # configure the analyzer (cf. base values are in the StandardSelections_cfi) # process.evAnalyzer = cms.EDAnalyzer("DileptonPlusMETEventAnalyzer", dtag=cms.string('llvv'), Trigger = BaseTriggerSelection.clone(), Generator = BaseGeneratorSelection.clone(), Vertices = BaseVertexSelection.clone(), Photons = BasePhotonsSelection.clone(), LooseMuons = BaseLooseMuonsSelection.clone(), Muons = BaseMuonsSelection.clone(), LooseElectrons = BaseLooseElectronsSelection.clone(), Electrons = BaseElectronsSelection.clone(), Dileptons = BaseDileptonSelection.clone(), Jets = BaseJetSelection.clone(), AssocJets = AssocJetSelection.clone(), MET = BaseMetSelection.clone() ) if(castorDir.find('12_03_13_HZZ2l2v_pat')>0): print ' Warning: applying PF muon patch to standard selection' process.evAnalyzer.Muons.source=cms.InputTag("selectedPatMuonsPFlow") process.evAnalyzer.Muons.sourceIsPF=cms.bool(True) process.evAnalyzer.LooseMuons.source=process.evAnalyzer.Muons.source process.evAnalyzer.LooseMuons.sourceIsPF=process.evAnalyzer.Muons.sourceIsPF #MVAs for IDs #process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi') #process.mvaIDs = cms.Sequence( process.mvaTrigV0 + process.mvaNonTrigV0 ) from JetMETCorrections.Configuration.JetCorrectionProducers_cff import ak5PFJetsL1L2L3 process.ak5PFJetsL1L2L3ForMVAMET=ak5PFJetsL1L2L3.clone() #rho for muon isolation if(reRunRho) : process.pfAllNeutralHadronsAndPhotons = pfAllNeutralHadronsAndPhotons.clone( src=cms.InputTag("particleFlow") ) process.kt6PFJetsCentralNeutral = kt4PFJets.clone( src = cms.InputTag("pfAllNeutralHadronsAndPhotons"), rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Ghost_EtaMax = cms.double(3.1), Rho_EtaMax = cms.double(2.5), inputEtMin = cms.double(0.5) ) process.rhoForIsolationSequence = cms.Sequence(process.pfAllNeutralHadronsAndPhotons*process.kt6PFJetsCentralNeutral) process.analysis = cms.Path( #process.mvaIDs + process.rhoForIsolationSequence + process.ak5PFJetsL1L2L3ForMVAMET + process.ClusteredPFMetProducer + process.evAnalyzer) else : process.analysis = cms.Path( #process.mvaIDs + process.ak5PFJetsL1L2L3ForMVAMET + process.ClusteredPFMetProducer + process.evAnalyzer)
def customizeHLTforMC(process): """adapt the HLT to run on MC, instead of data see Configuration/StandardSequences/Reconstruction_Data_cff.py which does the opposite, for RECO""" # PFRecHitProducerHCAL if 'hltParticleFlowRecHitHCAL' in process.__dict__: process.hltParticleFlowRecHitHCAL.ApplyPulseDPG = cms.bool(False) process.hltParticleFlowRecHitHCAL.LongShortFibre_Cut = cms.double(1000000000.0) # customise hltHbhereco to use the Method 3 time slew parametrization and response correction for Monte Carlo (PR #11091) if 'hltHbhereco' in process.__dict__: if process.hltHbhereco._TypedParameterizable__type == 'HcalHitReconstructor': # 2015-2016 Run 2 process.hltHbhereco.pedestalSubtractionType = cms.int32( 1 ) process.hltHbhereco.pedestalUpperLimit = cms.double( 2.7 ) process.hltHbhereco.timeSlewParsType = cms.int32( 3 ) # new time slew parametrisation process.hltHbhereco.timeSlewPars = cms.vdouble( 12.2999, -2.19142, 0, 12.2999, -2.19142, 0, 12.2999, -2.19142, 0 ) # old response correction, matching the 2015D 25ns data process.hltHbhereco.respCorrM3 = cms.double( 1.0 ) elif process.hltHbhereco._TypedParameterizable__type == 'HBHEPhase1Reconstructor': # 2017 "plan 0" process.hltHbhereco.algorithm.respCorrM3 = cms.double( 1.0 ) if 'hltHbhePhase1Reco' in process.__dict__: if process.hltHbhePhase1Reco._TypedParameterizable__type == 'HBHEPhase1Reconstructor': # 2017 "plan 1" process.hltHbhePhase1Reco.algorithm.respCorrM3 = cms.double( 1.0 ) return process
def get(todo): defs = {} defs["JetViewPFAK4CHS"] = cms.PSet( miniView = cms.string("JetView"), storeageVersion = cms.untracked.int32(1), disableJetID = cms.bool(True), optionalCaloJets4ID = cms.InputTag("ak5CaloJets","","RECO"), optionalCaloID4ID = cms.InputTag("ak5JetID"), branchPrefix = cms.untracked.string("PFAK4CHS"), maxEta = cms.double(5.2), minPt = cms.double(3), maxnum = cms.int32(3), input = cms.InputTag("selectedPatJetsAK4PFCHSCopy"), variations= cms.vstring("", "jecUp", "jecDown"), jerFactors = cms.vstring( # PF10 "5.5 1 0.007 0.07 0.072"), ) # and so on # defs["JetViewAK4Calo"]= cmsPSet(... ret = {} for t in todo: if t not in defs: raise Exception("miniView def not known "+t) ret[t] = defs[t] return ret
def turn_on_Pixel_aging_1000(process): # just incase we want aging afterall if hasattr(process, "mix") and hasattr(process.mix, "digitizers") and hasattr(process.mix.digitizers, "hcal"): process.mix.digitizers.pixel.PseudoRadDamage = cms.double(1.5) process.mix.digitizers.pixel.PseudoRadDamageRadius = cms.double(4.0) return process
def customise(process): if hasattr(process.VtxSmeared,"X0"): VertexX = process.VtxSmeared.X0 VertexY = process.VtxSmeared.Y0 VertexZ = process.VtxSmeared.Z0 if hasattr(process.VtxSmeared,"MeanX"): VertexX = process.VtxSmeared.MeanX VertexY = process.VtxSmeared.MeanY VertexZ = process.VtxSmeared.MeanZ process.load("SimG4Core.Application.g4SimHits_cfi") process.g4SimHits.Generator.HepMCProductLabel = 'LHCTransport' process.g4SimHits.Generator.MinEtaCut = -13.0 process.g4SimHits.Generator.MaxEtaCut = 13.0 process.g4SimHits.SteppingAction.MaxTrackTime = cms.double(2000.0) process.g4SimHits.StackingAction.MaxTrackTime = cms.double(2000.0) process.load('SimTransport.HectorProducer.HectorTransportCTPPS_cfi') process.LHCTransport.CTPPSHector.VtxMeanX = VertexX process.LHCTransport.CTPPSHector.VtxMeanY = VertexY process.LHCTransport.CTPPSHector.VtxMeanZ = VertexZ process.transport_step = cms.Path(process.LHCTransport) process.psim = cms.Sequence(cms.SequencePlaceholder("randomEngineStateProducer")*process.LHCTransport*process.g4SimHits) return(process)
def loadElectronScaleFactor(filename): import json with open(filename) as f: data = json.load(f) etaBins = data["eta"] ptBins = data["pt"] mainSet = cms.VPSet() for i in range(0, len(etaBins) - 1): etaSet = cms.VPSet() for j in range(0, len(ptBins) - 1): pset = cms.PSet( pt = cms.vdouble(float(ptBins[j]), float(ptBins[j + 1])), value = cms.double(float(data["sf"][i][j][0])), error_high = cms.double(float(data["sf"][i][j][1])), error_low = cms.double(float(data["sf"][i][j][2])), ) etaSet.append(pset) mainSet.append( cms.PSet( eta = cms.vdouble(float(etaBins[i]), float(etaBins[i + 1])), SF = etaSet ) ) return mainSet
def adjust_cone_radius(R,pfJetsJetrecoPrototype,LAJets): # rtag = "R%d" % (R*100.0) latag = "LA"+str(LAJets) # newPFReco = pfJetsJetrecoPrototype.clone( recoScaleCalcPeak = cms.PSet( Class = cms.string("ConstDouble"), value = cms.double(R) ), recoScaleCalcJet = cms.PSet( Class = cms.string("ConstDouble"), value = cms.double(R) ) ) newPFReco_module = "fftPFJetReco"+latag+rtag # newPFReco.resolution = cms.string('locallyAdaptive') newPFReco.nClustersRequested = cms.uint32(LAJets) newPFCorr = configure_fftjet_correction_producer( (jetCorrectionSequenceTag,), newPFReco_module) newPFCorr.verbose = cms.untracked.bool(False) newPFCorr.calculatePileup = cms.bool(False) newPFCorr.subtractPileup = cms.bool(False) newPFCorr_module = "fftPFJetCorrected"+latag+rtag return ((newPFReco, newPFReco_module), (newPFCorr, newPFCorr_module) )
def initJetAreaSequence(process): jamedian_pt_jets_value=0. eta_max_ghosts=6. from RecoJets.JetProducers.AnomalousCellParameters_cfi import AnomalousCellParameters from RecoJets.JetProducers.GenJetParameters_cfi import GenJetParameters GenJetParameters.doPUFastjet = cms.bool(False) GenJetParameters.doAreaFastjet = cms.bool(True) GenJetParameters.doRhoFastjet = cms.bool(True) GenJetParameters.Active_Area_Repeats = cms.int32(1) GenJetParameters.jetPtMin = cms.double(jamedian_pt_jets_value) GenJetParameters.Ghost_EtaMax= cms.double(eta_max_ghosts) process.kt2GenJetsWithArea = cms.EDProducer("FastjetJetProducer", GenJetParameters, AnomalousCellParameters, jetAlgorithm = cms.string("Kt"), rParam = cms.double(0.2) ) process.kt4GenJetsWithArea=process.kt2GenJetsWithArea.clone(rParam=0.4) process.kt8GenJetsWithArea=process.kt2GenJetsWithArea.clone(rParam=0.8) process.kt12GenJetsWithArea=process.kt2GenJetsWithArea.clone(rParam=1.2) process.GenJetsWithAreaSeq=cms.Sequence(process.kt2GenJetsWithArea+ process.kt4GenJetsWithArea+ process.kt8GenJetsWithArea+ process.kt12GenJetsWithArea)
def customiseCommon(process): ##################################################################################################### #### #### Top level replaces for handling strange scenarios of early collisions #### ## TRACKING: ## Skip events with HV off process.newSeedFromTriplets.ClusterCheckPSet.MaxNumberOfPixelClusters=2000 process.newSeedFromPairs.ClusterCheckPSet.MaxNumberOfCosmicClusters=20000 process.secTriplets.ClusterCheckPSet.MaxNumberOfPixelClusters=2000 process.fifthSeeds.ClusterCheckPSet.MaxNumberOfCosmicClusters = 20000 process.fourthPLSeeds.ClusterCheckPSet.MaxNumberOfCosmicClusters=20000 process.thTripletsA.ClusterCheckPSet.MaxNumberOfPixelClusters = 5000 process.thTripletsB.ClusterCheckPSet.MaxNumberOfPixelClusters = 5000 ###### FIXES TRIPLETS FOR LARGE BS DISPLACEMENT ###### ### prevent bias in pixel vertex process.pixelVertices.useBeamConstraint = False ### pixelTracks #---- new parameters ---- process.pixelTracks.RegionFactoryPSet.RegionPSet.nSigmaZ = 4.06 process.pixelTracks.RegionFactoryPSet.RegionPSet.originHalfLength = cms.double(40.6) ### 0th step of iterative tracking #---- new parameters ---- process.newSeedFromTriplets.RegionFactoryPSet.RegionPSet.nSigmaZ = cms.double(4.06) process.newSeedFromTriplets.RegionFactoryPSet.RegionPSet.originHalfLength = 40.6 ### 2nd step of iterative tracking #---- new parameters ---- process.secTriplets.RegionFactoryPSet.RegionPSet.nSigmaZ = cms.double(4.47) process.secTriplets.RegionFactoryPSet.RegionPSet.originHalfLength = 44.7 ## Primary Vertex process.offlinePrimaryVerticesWithBS.PVSelParameters.maxDistanceToBeam = 2 process.offlinePrimaryVerticesWithBS.TkFilterParameters.maxNormalizedChi2 = 20 process.offlinePrimaryVerticesWithBS.TkFilterParameters.maxD0Significance = 100 process.offlinePrimaryVerticesWithBS.TkFilterParameters.minPixelLayersWithHits = 2 process.offlinePrimaryVerticesWithBS.TkFilterParameters.minSiliconLayersWithHits = 5 process.offlinePrimaryVerticesWithBS.TkClusParameters.TkGapClusParameters.zSeparation = 1 process.offlinePrimaryVertices.PVSelParameters.maxDistanceToBeam = 2 process.offlinePrimaryVertices.TkFilterParameters.maxNormalizedChi2 = 20 process.offlinePrimaryVertices.TkFilterParameters.maxD0Significance = 100 process.offlinePrimaryVertices.TkFilterParameters.minPixelLayersWithHits = 2 process.offlinePrimaryVertices.TkFilterParameters.minSiliconLayersWithHits = 5 process.offlinePrimaryVertices.TkClusParameters.TkGapClusParameters.zSeparation = 1 ## ECAL process.ecalRecHit.ChannelStatusToBeExcluded = [ 1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 14, 78, 142 ] ### ### end of top level replacements ### ############################################################################################### return (process)
def makePuppies( process ): process.load('CommonTools.PileupAlgos.Puppi_cff') process.pfNoLepPUPPI = cms.EDFilter("PdgIdCandViewSelector", src = cms.InputTag("particleFlow"), pdgId = cms.vint32( 1,2,22,111,130,310,2112,211,-211,321,-321,999211,2212,-2212 ) ) process.pfLeptonsPUPPET = cms.EDFilter("PdgIdCandViewSelector", src = cms.InputTag("particleFlow"), pdgId = cms.vint32(-11,11,-13,13), ) process.puppiNoLep = process.puppi.clone() process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI') process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET')) ## puppi met process.puppiForMET = cms.EDProducer("PuppiPhoton", candName = cms.InputTag('packedPFCandidates'), puppiCandName = cms.InputTag('puppi'), photonName = cms.InputTag('slimmedPhotons'), photonId = cms.InputTag("egmPhotonIDs:cutBasedPhotonID_PHYS14_PU20bx25_V2p1-standalone-loose"), pt = cms.double(10), useRefs = cms.bool(True), dRMatch = cms.vdouble(10,10,10,10), pdgids = cms.vint32 (22,11,211,130), weight = cms.double(1.), useValueMap = cms.bool(False), weightsName = cms.InputTag('puppi'), ) process.puppiForMET.puppiCandName = 'puppiMerged'
def configureFakeRateProductionPAT(process, recoTauProducerName = 'hpsPFTauProducer', recoTauPreselFlag = 'ewkTauId', patTauProducerName = 'patTaus', frSet = 'ewkTauIdHPSloose', method = None, prePatProdSequenceName = "producePrePat"): # check validity of method parameter if method is None: raise ValueError("Undefined method Parameter !!") else: if method != "simple" and method != "CDF": raise ValueError("Invalid method Parameter !!") prePatProdSequence = getattr(process, prePatProdSequenceName) # produce fake-rates frProdConfigRECO = configureFakeRateProductionRECO(process, recoTauProducerName, frSet) prePatProdSequence += frProdConfigRECO['sequence'] # compute fake-rate weights # # NOTE: jet weights are computed for all (shrinking signal cone) reco::PFTaus, # but only those tau-jet candidates passing preselection on PAT level # must enter event weight computation on analysis level !! # process.load("TauAnalysis.BgEstimationTools.fakeRateJetWeightProducer_cfi") process.bgEstFakeRateJetWeights.frTypes = cms.PSet() for frType, patLUT in frProdConfigRECO['frConfig'].items(): pset = cms.PSet( tauJetDiscriminators = cms.VPSet(cms.PSet( tauJetIdEffSource = cms.InputTag(frProdConfigRECO['frConfig']['ZTTsim']), qcdJetFakeRateSource = cms.InputTag(patLUT), tauJetDiscrSource = cms.InputTag(recoTauPreselFlag) )) ) setattr(process.bgEstFakeRateJetWeights.frTypes, frType, pset) process.bgEstFakeRateJetWeights.allTauJetSource = cms.InputTag(recoTauProducerName) process.bgEstFakeRateJetWeights.preselTauJetSource = cms.InputTag(recoTauProducerName) process.bgEstFakeRateJetWeights.method = method # EK: put a minPt cut on the taus so we don't get a ton of errors. process.bgEstFakeRateJetWeights.minJetPt = 17.0 prePatProdSequence += process.bgEstFakeRateJetWeights # add jet weights computed for tau id. efficiency shifted up/down by one sigma if method == "CDF": process.bgEstFakeRateJetWeightsSysTauIdEffUp = copy.deepcopy(process.bgEstFakeRateJetWeights) process.bgEstFakeRateJetWeightsSysTauIdEffUp.shiftTauIdEff = cms.double(+0.23) prePatProdSequence += process.bgEstFakeRateJetWeightsSysTauIdEffUp process.bgEstFakeRateJetWeightsSysTauIdEffDown = copy.deepcopy(process.bgEstFakeRateJetWeights) process.bgEstFakeRateJetWeightsSysTauIdEffDown.shiftTauIdEff = cms.double(-0.23) prePatProdSequence += process.bgEstFakeRateJetWeightsSysTauIdEffDown # add fake-rates to pat::Tau frConfigParameters = getFakeRateConfigParameters(process) patTauProducer = getattr(process, patTauProducerName) for frType, frConfig in frConfigParameters.items(): setattr(patTauProducer.efficiencies, frConfig['patLabel'], frConfig['srcJetWeight']) patTauProducer.addEfficiencies = cms.bool(True) return frProdConfigRECO
def customise(process): process.g4SimHits.StackingAction.RusRoEcalNeutron = cms.double(0.3) process.g4SimHits.StackingAction.RusRoEcalNeutronLimit = cms.double(10.0) process.g4SimHits.StackingAction.RusRoHcalNeutron = cms.double(0.3) process.g4SimHits.StackingAction.RusRoHcalNeutronLimit = cms.double(10.0) return process
def customise(process): # extended geometric acceptance (full CASTOR acceptance) process.g4SimHits.Generator.MinEtaCut = cms.double(-7.7) process.g4SimHits.CastorSD.nonCompensationFactor = cms.double(0.77) return(process)
def customiseRR(process): # Russian roulette disabled - by default it is enabled if hasattr(process,'g4SimHits'): process.g4SimHits.StackingAction.RusRoGammaEnergyLimit = cms.double(0.0) process.g4SimHits.StackingAction.RusRoNeutronEnergyLimit = cms.double(0.0) return(process)
def addFatJet(process): from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets process.ca8PFJetsCHS = ak5PFJets.clone( src = 'pfNoPileUp', jetPtMin = cms.double(10.0), doAreaFastjet = cms.bool(True), rParam = cms.double(0.8), jetAlgorithm = cms.string("CambridgeAachen"), ) jetSource = 'ca8PFJetsCHS' # corrections from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import patJetCorrFactors process.patJetCorrFactorsCA8CHS = patJetCorrFactors.clone() process.patJetCorrFactorsCA8CHS.src = jetSource # will need to add L2L3 corrections in the cfg process.patJetCorrFactorsCA8CHS.levels = ['L1FastJet', 'L2Relative', 'L3Absolute'] process.patJetCorrFactorsCA8CHS.payload = 'AK7PFchs' process.patJetCorrFactorsCA8CHS.useRho = True # pat jet from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import patJets process.patJetsCA8CHS = patJets.clone() process.patJetsCA8CHS.jetSource = jetSource process.patJetsCA8CHS.addJetCharge = False process.patJetsCA8CHS.embedCaloTowers = False process.patJetsCA8CHS.embedPFCandidates = False process.patJetsCA8CHS.addAssociatedTracks = False process.patJetsCA8CHS.addBTagInfo = False process.patJetsCA8CHS.addDiscriminators = False process.patJetsCA8CHS.getJetMCFlavour = False process.patJetsCA8CHS.jetCorrFactorsSource = cms.VInputTag(cms.InputTag('patJetCorrFactorsCA8CHS')) process.patJetsCA8CHS.genPartonMatch = cms.InputTag('patJetPartonMatchCA8CHS') process.patJetsCA8CHS.genJetMatch = cms.InputTag('patJetGenJetMatchCA8CHS') from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.selectedPatJetsCA8CHS = selectedPatJets.clone() process.selectedPatJetsCA8CHS.src = 'patJetsCA8CHS' process.selectedPatJetsCA8CHS.cut = 'pt()>20' #process.jetMCSequenceCA8CHS = cms.Sequence( #process.patJetPartonMatchCA8CHS + #process.genParticlesForJetsNoNu + #process.ca8GenJetsNoNu + #process.patJetGenJetMatchCA8CHS #) process.PATJetSequenceCA8CHS = cms.Sequence( process.ca8PFJetsCHS + #process.jetMCSequenceCA8CHS + process.patJetCorrFactorsCA8CHS #process.patJetsCA8CHS + #process.selectedPatJetsCA8CHS ) process.PATJetPathCA8CHS = cms.Path ( process.PATJetSequenceCA8CHS )
def get(todo): defs = {} defs["ak5CastorJetView"]= cms.PSet( miniView = cms.string("CastorJetView"), branchPrefix = cms.untracked.string("ak5CastorJets"), minCastorJetEnergy = cms.double(100.), jetRadius = cms.double(0.5) ) defs["ak7CastorJetView"]= cms.PSet( miniView = cms.string("CastorJetView"), branchPrefix = cms.untracked.string("ak7CastorJets"), minCastorJetEnergy = cms.double(100.), jetRadius = cms.double(0.7) ) defs["CastorRecHitViewFull"]= cms.PSet( miniView = cms.string("CastorRecHitView"), branchPrefix = cms.untracked.string("CastorRecHit"), onlyGoodRecHits = cms.bool(False), writeSaturationInfo = cms.bool(True), ) defs["CastorRecHitViewBasic"]= cms.PSet( miniView = cms.string("CastorRecHitView"), branchPrefix = cms.untracked.string("CastorRecHit"), onlyGoodRecHits = cms.bool(True), writeSaturationInfo = cms.bool(False), ) defs["TriggerResultsView"] = cms.PSet( miniView = cms.string("TriggerResultsView"), branchPrefix = cms.untracked.string("trg"), process = cms.string("HLT"), # usually HLT triggers = cms.vstring("randoms","noBPTX","zeroBias"), randoms = cms.vstring("HLT_Random_v2*"), noBPTX = cms.vstring("HLT_L1Tech7_NoBPTX_v1*"), zeroBias = cms.vstring("HLT_ZeroBias_part0_v1*"), ) defs["VerticesView"]= cms.PSet( miniView = cms.string("VerticesView"), branchPrefix = cms.untracked.string("Vtx"), src = cms.InputTag("offlinePrimaryVertices"), ) defs["CastorTowerView"] = cms.PSet( miniView = cms.string("CastorTowerView"), branchPrefix = cms.untracked.string("CastorTower"), inputcoll = cms.InputTag("CastorTowerReco") ) ret = {} for t in todo: if t not in defs: raise Exception("miniView def not known "+t) ret[t] = defs[t] return ret
def psetNormalizedGsfChi2Cut(wpEB, wpEE): return cms.PSet( cutName = cms.string('GsfEleNormalizedGsfChi2Cut'), normalizedGsfChi2CutValueEB = cms.double( wpEB.normalizedGsfChi2Cut ), normalizedGsfChi2CutValueEE = cms.double( wpEE.normalizedGsfChi2Cut ), barrelCutOff = cms.double(ebCutOff), needsAdditionalProducts = cms.bool(False), isIgnored = cms.bool(False) )
def psetEInerseMinusPInverseCut(wpEB, wpEE): return cms.PSet( cutName = cms.string('GsfEleEInverseMinusPInverseCut'), eInverseMinusPInverseCutValueEB = cms.double( wpEB.absEInverseMinusPInverseCut ), eInverseMinusPInverseCutValueEE = cms.double( wpEE.absEInverseMinusPInverseCut ), barrelCutOff = cms.double(ebCutOff), needsAdditionalProducts = cms.bool(False), isIgnored = cms.bool(False) )
def psetDPhiInCut(wpEB, wpEE): return cms.PSet( cutName = cms.string('GsfEleDPhiInCut'), dPhiInCutValueEB = cms.double( wpEB.dPhiInCut ), dPhiInCutValueEE = cms.double( wpEE.dPhiInCut ), barrelCutOff = cms.double(ebCutOff), needsAdditionalProducts = cms.bool(False), isIgnored = cms.bool(False) )
def psetHadronicOverEMCut(wpEB, wpEE): return cms.PSet( cutName = cms.string('GsfEleHadronicOverEMCut'), hadronicOverEMCutValueEB = cms.double( wpEB.hOverECut ), hadronicOverEMCutValueEE = cms.double( wpEE.hOverECut ), barrelCutOff = cms.double(ebCutOff), needsAdditionalProducts = cms.bool(False), isIgnored = cms.bool(False) )
'L1TriggerConfig.L1GtConfigProducers.L1GtTriggerMaskTechTrigConfig_cff') process.load('HLTrigger/HLTfilters/hltLevel1GTSeed_cfi') #################################################################################### ##################################good collisions############################################ #### 44x #process.primaryVertexFilter = cms.EDFilter("GoodVertexFilter", # vertexCollection = cms.InputTag('offlinePrimaryVertices'), # minimumNDOF = cms.uint32(4) , # maxAbsZ = cms.double(24), # maxd0 = cms.double(2) # ) ## 53x pvSelection = cms.PSet(minNdof=cms.double(4.), maxZ=cms.double(24.), maxRho=cms.double(2.)) process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", # checks for fake PVs automatically filterParams=pvSelection, filter=cms.bool(False), # use only as producer src=cms.InputTag('offlinePrimaryVertices')) process.primaryVertexFilter = process.goodOfflinePrimaryVertices.clone( filter=True) process.noscraping = cms.EDFilter( "FilterOutScraping", applyfilter=cms.untracked.bool(True),
import FWCore.ParameterSet.Config as cms #from Configuration.Generator.PythiaUEZ2Settings_cfi import * from Configuration.Generator.PythiaUEZ2starSettings_cfi import * generator = cms.EDFilter( "Pythia6HadronizerFilter", pythiaHepMCVerbosity=cms.untracked.bool(False), maxEventsToPrint=cms.untracked.int32(0), pythiaPylistVerbosity=cms.untracked.int32(0), comEnergy=cms.double(8000.0), PythiaParameters=cms.PSet( pythiaUESettingsBlock, processParameters=cms.vstring( 'MSTP(1) = 4', 'MSEL=7 ! User defined processes', 'MWID(7)=2', 'MSTJ(1)=1 ! Fragmentation/hadronization on or off', 'MSTP(61)=1 ! Parton showering on or off', 'PMAS(5,1)=4.8 ! b quark mass', #from Spring11 4000040 'PMAS(6,1)=172.5 ! t quark mass', #from Spring11 4000040 'PMAS(7,1) = 1500.0D0 ! bprime quarks mass', 'PMAS(7,2) = 15.0D0', 'PMAS(7,3) = 150.0D0', 'VCKM(1,1) = 0.97414000D0', 'VCKM(1,2) = 0.22450000D0', 'VCKM(1,3) = 0.00420000D0', 'VCKM(1,4) = 0.02500000D0', 'VCKM(2,1) = 0.22560000D0', 'VCKM(2,2) = 0.97170000D0', 'VCKM(2,3) = 0.04109000D0', 'VCKM(2,4) = 0.05700000D0',
import FWCore.ParameterSet.Config as cms # # This is the include file with the parameters # for the DTCombinatorialPatternReco algorithm, # which is the concrete algo for the DTRecSegment2D production. # The linear Drift algos is used. # # The reconstruction algo and its parameter set from RecoLocalMuon.DTRecHit.DTLinearDriftAlgo_cfi import * DTCombinatorialPatternReco2DAlgo_LinearDrift = cms.PSet( Reco2DAlgoConfig=cms.PSet( # Parameters for the updator # this is the RecHit1D algo!! DTLinearDriftAlgo, segmCleanerMode=cms.int32(2), AlphaMaxPhi=cms.double(1.0), MaxAllowedHits=cms.uint32(50), # Parameters for the cleaner nSharedHitsMax=cms.int32(2), AlphaMaxTheta=cms.double(0.9), debug=cms.untracked.bool(False), nUnSharedHitsMin=cms.int32(2), # Parameters for T0 fit segment in the Updator and hit_afterT0_resolution=cms.double(0.03), performT0_vdriftSegCorrection=cms.bool(False), performT0SegCorrection=cms.bool(False)), Reco2DAlgoName=cms.string('DTCombinatorialPatternReco'))
def getZeroBias_SinglePixelTrackVPSet(): ret = cms.VPSet() partialPathName = "HLT_ZeroBias_SinglePixelTrack_v" hltPixelTracksZB = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("FromHLT"), partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltMinBiasPixelFilt"), dqmhistolabel=cms.string("hltPixelTracks"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("1==1"), singleObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("pt"), expression=cms.string("pt"), bins=cms.int32(50), min=cms.double(0.4), max=cms.double(10)), cms.PSet(name=cms.string("eta"), expression=cms.string("eta"), bins=cms.int32(100), min=cms.double(-2.5), max=cms.double(2.5)), cms.PSet(name=cms.string("phi"), expression=cms.string("phi"), bins=cms.int32(100), min=cms.double(-3.15), max=cms.double(3.15))), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string("at(0).pt"), combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet()) ret.append(hltPixelTracksZB) # note: for global efficiency (ie not efficiency as a funtion of something) # calculation we use RecoTrack handler in a bit twisted way. # RecoTrack handler assumes, that the efficiency calculation is done # only for events with at least one offline track (from generalTracks collection) # passing the selection criteria from singleObjectsPreselection variable # Such events are used to fill 1-bin-large-histogram with a range -0.5...0.5 # Note, that the histogram is always filled with the 0 value ("0*" part in # expression string). The "at(0).pt()" part is needed to make expression parses # happy. tracksCountZB = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("RecoTrack"), inputCol=cms.InputTag("generalTracks"), # l parameters partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltL1sETT"), dqmhistolabel=cms.string("zb"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("pt > 0.4 && abs(eta) < 2.4"), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string('at(0).pt()'), # doesnt matter combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("Eff_nominator"), expression=cms.string('0*at(0).pt()'), bins=cms.int32(1), min=cms.double(-0.5), max=cms.double(0.5)))) ret.append(tracksCountZB) tracksCountDenomZB = tracksCountZB.clone( triggerSelection="HLT_ZeroBias_v*") tracksCountDenomZB.combinedObjectDrawables = cms.VPSet( cms.PSet(name=cms.string("Eff_denominator"), expression=cms.string("0*at(0).pt()"), bins=cms.int32(1), min=cms.double(-0.5), max=cms.double(0.5))) ret.append(tracksCountDenomZB) return ret
def getDoublePFJet(thresholds, flavour=None, etaMin=-1, srcType="genJets"): if srcType == "genJets": inputCol = cms.InputTag("ak4GenJets") handlerType = "FromRecoCandidate" label = srcType elif srcType == "ak4PFJetsCHS": inputCol = cms.InputTag("ak4PFJetsCHS") handlerType = "RecoPFJetWithJEC" label = srcType elif srcType == "hlt": inputCol = cms.InputTag("S") handlerType = "FromHLT" label = srcType else: raise Exception("Whooops!") combinedObjectSortCriteria = "at(0).pt + at(1).pt" combinedObjectSelection = "1 == 1" if flavour != None and "FB" in flavour: combinedObjectSortCriteria = "(" + combinedObjectSortCriteria + ")*( ? at(0).eta*at(1).eta < 0 ? 1 : 0 )" combinedObjectSelection = "at(0).eta*at(1).eta < 0" if etaMin == None: etaMin = -1 ret = cms.VPSet() for t in thresholds: partialPathName = "HLT_DiPFJet" + str(t) + "_" if flavour != None: partialPathName += flavour + "_" partialPathName += "v" marginLow = max(t - t // 2, 15) ptBinLow = max(t - marginLow, 0) marginHigh = min(max(t // 3, 15), 50) ptBinHigh = t + marginHigh ptBins = min(100, ptBinHigh - ptBinLow) fromJets = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string(handlerType), PFJetCorLabel=cms.InputTag("ak4PFL1FastL2L3Corrector"), inputCol=inputCol, partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltDoublePFJet"), dqmhistolabel=cms.string(label), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string( "abs(eta) < 5.5 && abs(eta) > " + str(etaMin)), #singleObjectsPreselection = cms.string("pt > 15 && abs(eta) < 5.5 && abs(eta) > " + str(etaMin) ), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string(combinedObjectSelection), combinedObjectSortCriteria=cms.string(combinedObjectSortCriteria), combinedObjectDimension=cms.int32(2), combinedObjectDrawables=cms.VPSet( #cms.PSet (name = cms.string("ptLead"), expression = cms.string("max(at(0).pt, at(1).pt())"), # bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)), #cms.PSet (name = cms.string("ptSublead"), expression = cms.string("min(at(0).pt, at(1).pt())"), # bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)), cms.PSet(name=cms.string("ptMostFwd"), expression=cms.string( "? at(0).eta > at(1).eta ? at(0).pt : at(1).pt"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet(name=cms.string("ptMostBkw"), expression=cms.string( "? at(0).eta > at(1).eta ? at(1).pt : at(0).pt"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet( name=cms.string("etaMostFwd"), expression=cms.string( "? at(0).eta > at(1).eta ? at(0).eta : at(1).eta"), bins=cms.int32(52), min=cms.double(-5.2), max=cms.double(5.2)), cms.PSet( name=cms.string("etaMostBkw"), expression=cms.string( "? at(0).eta > at(1).eta ? at(1).eta : at(0).eta"), bins=cms.int32(52), min=cms.double(-5.2), max=cms.double(5.2)), #cms.PSet (name = cms.string("pt_nominator"), expression = cms.string("min(at(0).pt, at(1).pt)"), # bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh) ) )) #fromJets.triggerSelection = cms.string("HLT_ZeroBias_v*") ret.append(fromJets) if srcType != "hlt": fromJets.combinedObjectDrawables.append( cms.PSet(name=cms.string("ptm_nominator"), expression=cms.string("min(at(0).pt, at(1).pt)"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh))) fromJetsDenom = fromJets.clone(triggerSelection="HLT_ZeroBias_v*") fromJetsDenom.singleObjectDrawables = cms.VPSet() fromJetsDenom.combinedObjectDrawables = cms.VPSet( cms.PSet(name=cms.string("ptm_denominator"), expression=cms.string("min(at(0).pt, at(1).pt)"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh))) ret.append(fromJetsDenom) return ret
import FWCore.ParameterSet.Config as cms # reference: https://github.com/cms-sw/genproductions/blob/master/python/EightTeV/SingleMuMinusFlatPt0p2To100_cff.py generator = cms.EDProducer("FlatRandomOneOverPtGunProducer", PGunParameters = cms.PSet( MaxOneOverPt = cms.double(0.5), MinOneOverPt = cms.double(0.0005), PartID = cms.vint32(13), MaxEta = cms.double(2.5), MaxPhi = cms.double(3.14159265359), MinEta = cms.double(-2.5), MinPhi = cms.double(-3.14159265359), #XFlatSpread = cms.double(1.5), ## in mm #YFlatSpread = cms.double(1.5), ## in mm #ZFlatSpread = cms.double(150.), ## in mm RandomCharge = cms.bool(True), ReallyFlat = cms.bool(True), ), Verbosity = cms.untracked.int32(0), psethack = cms.string('single muon+/- 1/pt 0.0005 to 0.5'), AddAntiParticle = cms.bool(False), firstRun = cms.untracked.uint32(1) )
# Setting input particle/jet collections to be used by the tools genParticleCollection = '' genJetCollection = 'ak4GenJetsCustom' if options.runOnAOD: genParticleCollection = 'genParticles' ## producing a subset of genParticles to be used for jet reclustering from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu process.genParticlesForJetsCustom = genParticlesForJetsNoNu.clone( src=genParticleCollection) patAlgosToolsTask.add(process.genParticlesForJetsCustom) # Producing own jets for testing purposes from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets process.ak4GenJetsCustom = ak4GenJets.clone( src='genParticlesForJetsCustom', rParam=cms.double(0.4), jetAlgorithm=cms.string("AntiKt")) patAlgosToolsTask.add(process.ak4GenJetsCustom) else: genParticleCollection = 'prunedGenParticles' genJetCollection = 'slimmedGenJets' # Supplies PDG ID to real name resolution of MC particles process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi") # Ghost particle collection used for Hadron-Jet association # MUST use proper input particle collection from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone( particles=genParticleCollection) patAlgosToolsTask.add(process.selectedHadronsAndPartons)
initialStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone( minimumNumberOfHits=3, minPt=0.2) import RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeTrajectoryFilter_cfi initialStepTrajectoryFilterShape = RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeTrajectoryFilter_cfi.StripSubClusterShapeTrajectoryFilterTIX12.clone( ) initialStepTrajectoryFilter = cms.PSet( ComponentType=cms.string('CompositeTrajectoryFilter'), filters=cms.VPSet( cms.PSet(refToPSet_=cms.string('initialStepTrajectoryFilterBase')), cms.PSet(refToPSet_=cms.string('initialStepTrajectoryFilterShape'))), ) import RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimatorESProducer_cfi initialStepChi2Est = RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimatorESProducer_cfi.Chi2ChargeMeasurementEstimator.clone( ComponentName=cms.string('initialStepChi2Est'), nSigma=cms.double(3.0), MaxChi2=cms.double(30.0), clusterChargeCut=cms.PSet( refToPSet_=cms.string('SiStripClusterChargeCutLoose')), pTChargeCutThreshold=cms.double(15.)) import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi initialStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone( trajectoryFilter=cms.PSet( refToPSet_=cms.string('initialStepTrajectoryFilter')), alwaysUseInvalidHits=True, maxCand=3, estimator=cms.string('initialStepChi2Est'), maxDPhiForLooperReconstruction=cms.double(2.0), maxPtForLooperReconstruction=cms.double(0.7))
import FWCore.ParameterSet.Config as cms from PhysicsTools.SelectorUtils.centralIDRegistry import central_id_registry ebMax = 1.4442 eeMin = 1.566 ebCutOff = 1.479 heepElectronID_HEEPV50_CSA14_startup = cms.PSet( idName=cms.string("heepElectronID-HEEPV50-CSA14-startup"), cutFlow=cms.VPSet( cms.PSet(cutName=cms.string("MinPtCut"), minPt=cms.double(35.0), needsAdditionalProducts=cms.bool(False), isIgnored=cms.bool(False)), cms.PSet(cutName=cms.string("GsfEleSCEtaMultiRangeCut"), useAbsEta=cms.bool(True), allowedEtaRanges=cms.VPSet( cms.PSet(minEta=cms.double(0.0), maxEta=cms.double(ebMax)), cms.PSet(minEta=cms.double(eeMin), maxEta=cms.double(2.5))), needsAdditionalProducts=cms.bool(False), isIgnored=cms.bool(False)), cms.PSet(cutName=cms.string('GsfEleDEtaInLinearCut'), constTermEB=cms.double(0.016), constTermEE=cms.double(0), slopeTermEB=cms.double(-1E-4), slopeTermEE=cms.double(0), minValueEB=cms.double(0.004), minValueEE=cms.double(0.02), needsAdditionalProducts=cms.bool(False),
from DQMOffline.RecoB.bTagTrackBProbabilityAnalysis_cff import * from DQMOffline.RecoB.bTagGenericAnalysis_cff import * from DQMOffline.RecoB.bTagSimpleSVAnalysis_cff import * from DQMOffline.RecoB.bTagSoftLeptonAnalysis_cff import * from DQMOffline.RecoB.bTagSoftLeptonByPtAnalysis_cff import * from DQMOffline.RecoB.bTagSoftLeptonByIPAnalysis_cff import * from DQMOffline.RecoB.bTagCommon_cff import * bTagValidation = cms.EDAnalyzer("BTagPerformanceAnalyzerMC", bTagCommonBlock, finalizeOnly = cms.bool(False), applyPtHatWeight = cms.bool(False), jetCorrection = cms.string(''), recJetMatching = cms.PSet( refJetCorrection = cms.string(''), recJetCorrection = cms.string(''), maxChi2 = cms.double(50), # Corrected calo jets sigmaDeltaR = cms.double(0.1), sigmaDeltaE = cms.double(0.15) ), finalizePlots = cms.bool(True), tagConfig = cms.VPSet( cms.PSet( bTagTrackIPAnalysisBlock, type = cms.string('TrackIP'), label = cms.InputTag("impactParameterTagInfos"), folder = cms.string("IPTag") ), cms.PSet( bTagCombinedSVAnalysisBlock, ipTagInfos = cms.InputTag("impactParameterTagInfos"),
addDiscriminators = True, addAssociatedTracks = True, addJetCharge = False, addJetID = False, getJetMCFlavour = True, addGenPartonMatch = True, addGenJetMatch = True, embedGenJetMatch = True, embedGenPartonMatch = True, # embedCaloTowers = False, # embedPFCandidates = True ) akFilter5PFNjettiness = Njettiness.clone( src = cms.InputTag("akFilter5PFJets"), R0 = cms.double( 0.5) ) akFilter5PFpatJetsWithBtagging.userData.userFloats.src += ['akFilter5PFNjettiness:tau1','akFilter5PFNjettiness:tau2','akFilter5PFNjettiness:tau3'] akFilter5PFJetAnalyzer = inclusiveJetAnalyzer.clone(jetTag = cms.InputTag("akFilter5PFpatJetsWithBtagging"), genjetTag = 'ak5HiGenJets', rParam = 0.5, matchJets = cms.untracked.bool(False), matchTag = 'patJetsWithBtagging', pfCandidateLabel = cms.untracked.InputTag('particleFlowTmp'), trackTag = cms.InputTag("hiGeneralTracks"), fillGenJets = True, isMC = True, doSubEvent = True, useHepMC = cms.untracked.bool(False), genParticles = cms.untracked.InputTag("genParticles"),
TPGWriteSli = cms.uint32(1), TPGWriteWei = cms.uint32(1), TPGWriteLut = cms.uint32(1), TPGWriteFgr = cms.uint32(1), TPGWriteBxt = cms.uint32(0), TPGWriteBtt = cms.uint32(0), #do not change writeToFiles = cms.bool(True), outFile = cms.string('TPG_beamv4_128_mc_ideal.txt'), #modif #### TPG config tag and version (if not given it will be automatically given ) #### TPGtag = cms.string('BEAMV4128MCIDEAL'), TPGversion = cms.uint32(1), #### TPG calculation parameters #### useTransverseEnergy = cms.bool(True), ## true when TPG computes transverse energy, false for energy Et_sat_EB = cms.double(128.0), ## Saturation value (in GeV) of the TPG before the compressed-LUT (rem: with 35.84 the TPG_LSB = crystal_LSB) Et_sat_EE = cms.double(128.0), ## Saturation value (in GeV) of the TPG before the compressed-LUT (rem: with 35.84 the TPG_LSB = crystal_LSB) sliding = cms.uint32(0), ## Parameter used for the FE data format, should'nt be changed weight_timeShift = cms.double(0.), ## weights are computed shifting the timing of the shape by this amount in ns: val>0 => shape shifted to the right weight_sampleMax = cms.uint32(3), ## position of the maximum among the 5 samples used by the TPG amplitude filter weight_unbias_recovery = cms.bool(True), ## true if weights after int conversion are forced to have sum=0. Pb, in that case it can't have sum f*w = 1 forcedPedestalValue = cms.int32(-3), ## use this value instead of getting it from DB or MC ## -1: means use value from DB or MC. ## -2: ped12 = 0 used to cope with FENIX bug ## -3: used with sFGVB: baseline subtracted is pedestal-offset*sin(theta)/G with G=mult*2^-(shift+2) pedestal_offset = cms.uint32(150), ## pedestal offset used with option forcedPedestalValue = -3 NOTE: depends on saturation scale (300 for 64 GeV) useInterCalibration = cms.bool(True), ## use or not values from DB. If not, 1 is assumed
from Configuration.AlCa.GlobalTag import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:mc', '') process.generator = cms.EDFilter( "Pythia6GeneratorFilter", ExternalDecays=cms.PSet(Tauola=cms.untracked.PSet( UseTauolaPolarization=cms.bool(True), InputCards=cms.PSet(mdtau=cms.int32(0), pjak2=cms.int32(0), pjak1=cms.int32(0))), parameterSets=cms.vstring('Tauola')), maxEventsToPrint=cms.untracked.int32(5), pythiaPylistVerbosity=cms.untracked.int32(0), filterEfficiency=cms.untracked.double(1.0), pythiaHepMCVerbosity=cms.untracked.bool(False), comEnergy=cms.double(8000.0), crossSection=cms.untracked.double(1.0), UseExternalGenerators=cms.untracked.bool(True), PythiaParameters=cms.PSet( pythiaUESettings=cms.vstring( 'MSTU(21)=1 ! Check on possible errors during program execution', 'MSTJ(22)=2 ! Decay those unstable particles', 'PARJ(71)=10 . ! for which ctau 10 mm', 'MSTP(33)=0 ! no K factors in hard cross sections', 'MSTP(2)=1 ! which order running alphaS', 'MSTP(51)=10042 ! structure function chosen (external PDF CTEQ6L1)', 'MSTP(52)=2 ! work with LHAPDF', 'PARP(82)=1.921 ! pt cutoff for multiparton interactions', 'PARP(89)=1800. ! sqrts for which PARP82 is set', 'PARP(90)=0.227 ! Multiple interactions: rescaling power', 'MSTP(95)=6 ! CR (color reconnection parameters)',
process.load('IOMC.RandomEngine.IOMC_cff') if hasattr(process, 'MessageLogger'): process.MessageLogger.categories.append('HCalGeom') process.MessageLogger.categories.append('HcalSim') process.TFileService = cms.Service("TFileService", fileName=cms.string('ehcaltb10.root')) process.load("IOMC.RandomEngine.IOMC_cff") process.RandomNumberGeneratorService.generator.initialSeed = 456789 process.RandomNumberGeneratorService.g4SimHits.initialSeed = 9876 process.RandomNumberGeneratorService.VtxSmeared.initialSeed = 123456789 process.common_beam_direction_parameters = cms.PSet( MinE=cms.double(50.0), MaxE=cms.double(50.0), PartID=cms.vint32(-211), MinEta=cms.double(0.2175), MaxEta=cms.double(0.2175), MinPhi=cms.double(-0.1309), MaxPhi=cms.double(-0.1309), BeamPosition=cms.double(-800.0)) process.source = cms.Source("EmptySource", firstRun=cms.untracked.uint32(1), firstEvent=cms.untracked.uint32(1)) process.generator = cms.EDProducer( "FlatRandomEGunProducer", PGunParameters=cms.PSet(process.common_beam_direction_parameters, ),
def getHighMultVPSet(): ret = cms.VPSet() thresholds = [60, 85, 110, 135, 160] for t in thresholds: partialPathName = "HLT_PixelTracks_Multiplicity" + str(t) + "_v" tracksL = 0 tracksH = 200 tracksBins = (tracksH - tracksL) // 5 tracksCount = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("RecoTrackCounterWithVertexConstraint"), inputCol=cms.InputTag("generalTracks"), # l parameters vtxCollection=cms.InputTag("offlinePrimaryVertices"), minNDOF=cms.int32(7), maxZ=cms.double(15), maxDZ=cms.double(0.12), maxDZ2dzsigma=cms.double(3), maxDXY=cms.double(0.12), maxDXY2dxysigma=cms.double(3), partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltL1sETT"), #dqmhistolabel = cms.string("hltPixelTracks"), dqmhistolabel=cms.string("recoTracks"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("pt > 0.4 && abs(eta) < 2.4"), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string('size()'), combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("count_nominator"), expression=cms.string('at(0)'), bins=cms.int32(tracksBins), min=cms.double(tracksL), max=cms.double(tracksH)))) ret.append(tracksCount) tracksCountDenom = tracksCount.clone(triggerSelection="TRUE") tracksCountDenom.combinedObjectDrawables = cms.VPSet( cms.PSet(name=cms.string("count_denominator"), expression=cms.string("at(0)"), bins=cms.int32(tracksBins), min=cms.double(tracksL), max=cms.double(tracksH))) ret.append(tracksCountDenom) hltPixelTracks = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("FromHLT"), partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hlt1HighMult"), dqmhistolabel=cms.string("hltPixelTracks"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("1==1"), singleObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("pt"), expression=cms.string("pt"), bins=cms.int32(200), min=cms.double(0.0), max=cms.double(10)), cms.PSet(name=cms.string("eta"), expression=cms.string("eta"), bins=cms.int32(100), min=cms.double(-2.5), max=cms.double(2.5)), cms.PSet(name=cms.string("phi"), expression=cms.string("phi"), bins=cms.int32(100), min=cms.double(-3.15), max=cms.double(3.15))), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string("at(0).pt"), combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet()) ret.append(hltPixelTracks) hltPixelTracksEta16to18 = hltPixelTracks.clone( singleObjectsPreselection='abs(eta) > 1.6 && abs(eta) < 1.8', dqmhistolabel="hltPixelTracksEta16to18") for i in hltPixelTracksEta16to18.singleObjectDrawables: if i.name == "eta": hltPixelTracksEta16to18.singleObjectDrawables.remove(i) ret.append(hltPixelTracksEta16to18) # FIXME: what variables it makes sense to plot in case of ETT seeds? l1 = cms.PSet(triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("FromHLT"), partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltL1sETT"), dqmhistolabel=cms.string("l1"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("1==1"), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string("at(0).pt"), combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("pt"), expression=cms.string("at(0).pt"), bins=cms.int32(256 // 4), min=cms.double(0), max=cms.double(256)), )) ret.append(l1) return ret
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.puJetIDParams_cfi import * #################################################################################################################### full_53x = cms.PSet( impactParTkThreshold=cms.double(1.), cutBased=cms.bool(False), tmvaWeights=cms.string( "CondFormats/JetMETObjects/data/TMVAClassificationCategory_JetID_53X_Dec2012.weights.xml" ), tmvaMethod=cms.string("JetIDMVAHighPt"), version=cms.int32(-1), tmvaVariables=cms.vstring( "nvtx", "dZ", "beta", "betaStar", "nCharged", "nNeutrals", "dR2Mean", "ptD", "frac01", "frac02", "frac03", "frac04", "frac05", ), tmvaSpectators=cms.vstring("jetPt", "jetEta", "jetPhi"), JetIdParams=full_53x_wp, label=cms.string("full53x"))
def getSinglePFJet(thresholds, flavour=None, etaMin=-1, srcType="genJets", partialPathName="HLT_PFJet", disableEff=False): if srcType == "genJets": inputCol = cms.InputTag("ak4GenJets") handlerType = "FromRecoCandidate" label = srcType elif srcType == "ak4PFJetsCHS": inputCol = cms.InputTag("ak4PFJetsCHS") handlerType = "RecoPFJetWithJEC" label = srcType elif srcType == "hlt": inputCol = cms.InputTag("S") handlerType = "FromHLT" label = srcType else: raise Exception("Whooops!") if etaMin == None: etaMin = -1 ret = cms.VPSet() for t in thresholds: partialPathNameLoc = partialPathName partialPathNameLoc += str(t) + "_" if flavour != None: partialPathNameLoc += flavour + "_" partialPathNameLoc += "v" marginLow = max(t - t // 2, 15) ptBinLow = max(t - marginLow, 0) marginHigh = min(max(t // 2, 20), 50) ptBinHigh = t + marginHigh ptBins = min(100, ptBinHigh - ptBinLow) fromJets = cms.PSet( triggerSelection=cms.string(partialPathNameLoc + "*"), handlerType=cms.string(handlerType), PFJetCorLabel=cms.InputTag("ak4PFL1FastL2L3Corrector"), inputCol=inputCol, # inputCol = cms.InputTag("ak4PFJetsCHS"), partialPathName=cms.string(partialPathNameLoc), partialFilterName=cms.string("hltSinglePFJet"), dqmhistolabel=cms.string(label), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string( "abs(eta) < 5.5 && abs(eta) > " + str(etaMin)), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string("at(0).pt"), combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("pt"), expression=cms.string("at(0).pt"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet(name=cms.string("eta"), expression=cms.string("at(0).eta"), bins=cms.int32(52), min=cms.double(-5.2), max=cms.double(5.2)), cms.PSet(name=cms.string("pt_nominator"), expression=cms.string("at(0).pt"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)))) if disableEff: for p in fromJets.combinedObjectDrawables: if p.name == cms.string("pt_nominator"): fromJets.combinedObjectDrawables.remove(p) break else: fromJetsDenom = fromJets.clone(triggerSelection="HLT_ZeroBias_v*") fromJetsDenom.singleObjectDrawables = cms.VPSet() fromJetsDenom.combinedObjectDrawables = cms.VPSet( cms.PSet(name=cms.string("pt_denominator"), expression=cms.string("at(0).pt"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh))) ret.append(fromJetsDenom) ret.append(fromJets) return ret
5.50039288E-09 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', 'pythia8CUEP8M1Settings',
def getPTAveVPSet(thresholds=[30, 60, 80, 100, 160, 220, 300], flavour="HFJEC", disableCalo=False): # HLT_DiPFJetAve35_HFJEC_v1 # HLT_DiPFJetAve15_Central_v1 if flavour == "HFJEC": probeEtaSelection = "abs(eta) > 2.7" probeEtaSelectionCombined = "abs(at(1).eta) > 2.7" elif flavour == "Central": probeEtaSelection = "abs(eta) < 2.7" probeEtaSelectionCombined = "abs(at(1).eta) < 2.7" else: raise Exception("Flavour not known " + flavour) ret = cms.VPSet() for t in thresholds: #partialPathName = "HLT_DiPFJetAve"+ str(t) +"_HFJEC_" partialPathName = "HLT_DiPFJetAve" + str(t) + "_" + flavour + "_v" ptBinLow = t // 2 ptBinHigh = max(100, t * 2) ptBins = min(100, ptBinHigh - ptBinLow) if not disableCalo: hltCalo = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("FromHLT"), partialPathName=cms.string(partialPathName), partialFilterName=cms.string( "ForHFJECBase" ), # note: this matches to hltSingleCaloJetXXXForHFJECBase dqmhistolabel=cms.string("hltCaloJets"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("abs(eta)<1.4 || " + probeEtaSelection), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string("at(0).pt"), combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("pt"), expression=cms.string("at(0).pt"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet(name=cms.string("eta"), expression=cms.string("at(0).eta"), bins=cms.int32(104), min=cms.double(-5.2), max=cms.double(5.2)))) ret.append(hltCalo) l1 = cms.PSet(triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("FromHLT"), partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltL1"), dqmhistolabel=cms.string("l1"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("1==1"), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string("1==1"), combinedObjectSortCriteria=cms.string("at(0).pt"), combinedObjectDimension=cms.int32(1), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("pt"), expression=cms.string("at(0).pt"), bins=cms.int32(256 // 4), min=cms.double(0), max=cms.double(256)), cms.PSet(name=cms.string("eta"), expression=cms.string("at(0).eta"), bins=cms.int32(104 // 4), min=cms.double(-5.2), max=cms.double(5.2)))) ret.append(l1) ''' hltPFSingle = cms.PSet( triggerSelection = cms.string(partialPathName+"*"), handlerType = cms.string("FromHLT"), partialPathName = cms.string(partialPathName), partialFilterName = cms.string("hltDiPFJetAve"), dqmhistolabel = cms.string("hltpfsingle"), mainDQMDirname = cms.untracked.string(fsqdirname), singleObjectsPreselection = cms.string("abs(eta)<1.4 || abs(eta) > 2.7 "), singleObjectDrawables = cms.VPSet(), combinedObjectSelection = cms.string("1==1"), combinedObjectSortCriteria = cms.string("at(0).pt"), combinedObjectDimension = cms.int32(1), combinedObjectDrawables = cms.VPSet( cms.PSet (name = cms.string("pt"), expression = cms.string("at(0).pt"), bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)), cms.PSet (name = cms.string("eta"), expression = cms.string("at(0).eta"), bins = cms.int32(104), min = cms.double(-5.2), max = cms.double(5.2)) ) ) ret.append(hltPFSingle) ''' hltPFtopology = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("FromHLT"), partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltDiPFJetAve"), dqmhistolabel=cms.string("hltPFJetsTopology"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("abs(eta)<1.4 || " + probeEtaSelection), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string( "abs(at(0).eta())< 1.4 && " + probeEtaSelectionCombined + " && abs(deltaPhi(at(0).phi, at(1).phi)) > 2.5"), combinedObjectSortCriteria=cms.string("(at(0).pt+at(1).pt)/2"), combinedObjectDimension=cms.int32(2), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("deltaEta"), expression=cms.string("abs(at(0).eta-at(1).eta)"), bins=cms.int32(70), min=cms.double(0), max=cms.double(7)), cms.PSet(name=cms.string("deltaPhi"), expression=cms.string( "abs(deltaPhi(at(0).phi, at(1).phi))"), bins=cms.int32(100), min=cms.double(0), max=cms.double(3.2)), cms.PSet(name=cms.string("ptAve"), expression=cms.string("(at(0).pt+at(1).pt)/2"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet( name=cms.string("ptTag"), expression=cms.string( "? abs(at(0).eta) < abs(at(1).eta) ? at(0).pt : at(1).pt " ), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet( name=cms.string("ptProbe"), expression=cms.string( "? abs(at(0).eta) < abs(at(1).eta) ? at(1).pt : at(0).pt " ), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)))) ret.append(hltPFtopology) ''' # FromJet recoThr = t recoPF = cms.PSet( triggerSelection = cms.string(partialPathName+"*"), handlerType = cms.string("FromRecoCandidate"), inputCol = cms.InputTag("ak4PFJetsCHS"), partialPathName = cms.string(partialPathName), partialFilterName = cms.string("hltDiPFJetAve"), dqmhistolabel = cms.string("recoJet"), mainDQMDirname = cms.untracked.string(fsqdirname), singleObjectsPreselection = cms.string("pt > + "+str(recoThr) +" && (abs(eta)<1.3 || abs(eta) > 2.8) "), singleObjectDrawables = cms.VPSet(), combinedObjectSelection = cms.string("1==1"), combinedObjectSortCriteria = cms.string("at(0).pt"), combinedObjectDimension = cms.int32(1), combinedObjectDrawables = cms.VPSet( cms.PSet (name = cms.string("pt"), expression = cms.string("at(0).pt"), bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)), cms.PSet (name = cms.string("eta"), expression = cms.string("at(0).eta"), bins = cms.int32(52), min = cms.double(-5.2), max = cms.double(5.2)) ) ) ret.append(recoPF) ''' recoThr = t // 2 recoPFtopology = cms.PSet( triggerSelection=cms.string(partialPathName + "*"), handlerType=cms.string("RecoPFJetWithJEC"), PFJetCorLabel=cms.InputTag("ak4PFL1FastL2L3Corrector"), inputCol=cms.InputTag("ak4PFJetsCHS"), partialPathName=cms.string(partialPathName), partialFilterName=cms.string("hltDiPFJetAve"), dqmhistolabel=cms.string("recoPFJetsTopology"), mainDQMDirname=cms.untracked.string(fsqdirname), singleObjectsPreselection=cms.string("pt > " + str(recoThr) + " && (abs(eta)<1.4 ||" + probeEtaSelection + ")"), singleObjectDrawables=cms.VPSet(), combinedObjectSelection=cms.string( "abs(at(0).eta())< 1.3 && " + probeEtaSelectionCombined + " && abs(deltaPhi(at(0).phi, at(1).phi)) > 2.5"), combinedObjectSortCriteria=cms.string("(at(0).pt+at(1).pt)/2"), combinedObjectDimension=cms.int32(2), combinedObjectDrawables=cms.VPSet( cms.PSet(name=cms.string("deltaEta"), expression=cms.string("abs(at(0).eta-at(1).eta)"), bins=cms.int32(70), min=cms.double(0), max=cms.double(7)), cms.PSet(name=cms.string("deltaPhi"), expression=cms.string( "abs(deltaPhi(at(0).phi, at(1).phi))"), bins=cms.int32(100), min=cms.double(0), max=cms.double(3.2)), cms.PSet(name=cms.string("ptAve"), expression=cms.string("(at(0).pt+at(1).pt)/2"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet( name=cms.string("ptTag"), expression=cms.string( "? abs(at(0).eta) < abs(at(1).eta) ? at(0).pt : at(1).pt " ), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet( name=cms.string("ptProbe"), expression=cms.string( "? abs(at(0).eta) < abs(at(1).eta) ? at(1).pt : at(0).pt " ), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), cms.PSet(name=cms.string("ptAve_nominator"), expression=cms.string("(at(0).pt+at(1).pt)/2"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh)), )) ret.append(recoPFtopology) recoPFtopologyDenom = recoPFtopology.clone( #triggerSelection = "HLTriggerFirstPath*", #triggerSelection = partialPathName+"*", triggerSelection="TRUE") recoPFtopologyDenom.combinedObjectDrawables = cms.VPSet( cms.PSet(name=cms.string("ptAve_denominator"), expression=cms.string("(at(0).pt+at(1).pt)/2"), bins=cms.int32(ptBins), min=cms.double(ptBinLow), max=cms.double(ptBinHigh))) ret.append(recoPFtopologyDenom) # RecoCandidateCounter ''' example on how to count objects recoThr = t//2 recoPFJetCnt = cms.PSet( triggerSelection = cms.string(partialPathName+"*"), handlerType = cms.string("RecoCandidateCounter"), inputCol = cms.InputTag("ak4PFJetsCHS"), partialPathName = cms.string(partialPathName), partialFilterName = cms.string("hltDiPFJetAve"), dqmhistolabel = cms.string("recoPFJetsCnt"), mainDQMDirname = cms.untracked.string(fsqdirname), singleObjectsPreselection = cms.string("pt > "+str(recoThr) +" && abs(eta)<1.4 || abs(eta) > 2.7 "), singleObjectDrawables = cms.VPSet(), combinedObjectSelection = cms.string("1==1"), combinedObjectSortCriteria = cms.string('size()'), combinedObjectDimension = cms.int32(1), combinedObjectDrawables = cms.VPSet( cms.PSet (name = cms.string("count"), expression = cms.string('at(0)'), bins = cms.int32(30), min = cms.double(0), max = cms.double(30)) ) ) ret.append(recoPFJetCnt) ''' return ret
import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * generator = cms.EDFilter("Pythia8GeneratorFilter", 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( 'ExcitedFermion:qqbar2tauStartau = on', 'ExcitedFermion:Lambda= 10000', '4000015:onMode = off', '4000015:onIfMatch = 15 22', '4000015:m0 = 3250'), parameterSets=cms.vstring( 'pythia8CommonSettings', 'pythia8CUEP8M1Settings', 'processParameters', )))
import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * source = cms.Source("EmptySource") generator = cms.EDFilter( "Pythia8GeneratorFilter", pythiaHepMCVerbosity=cms.untracked.bool(False), maxEventsToPrint=cms.untracked.int32(0), pythiaPylistVerbosity=cms.untracked.int32(1), filterEfficiency=cms.untracked.double(0.056), crossSection=cms.untracked.double(1189000.), comEnergy=cms.double(8000.0), # center of mass energy in GeV PythiaParameters=cms.PSet(pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, processParameters=cms.vstring( 'HardQCD:all = on', 'PhaseSpace:pTHatMin = 80.', 'PhaseSpace:pTHatMax = 170.'), parameterSets=cms.vstring( 'pythia8CommonSettings', 'pythia8CUEP8M1Settings', 'processParameters', ))) # if you need some filter modules define and configure them here genParticlesForFilter = cms.EDProducer( "GenParticleProducer", saveBarCodes=cms.untracked.bool(True), src=cms.InputTag("generator"), abortOnUnknownPDGCode=cms.untracked.bool(True))
1, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 45, 50, 55, 60, 65, 70, 80, 100, ), # -- (NBins, minVal, maxValue) for the Eta,Phi and nInterations efficiency plots parametersEta = cms.vdouble(48, -2.400, 2.400), parametersPhi = cms.vdouble(50, -3.142, 3.142), parametersPu = cms.vdouble(10, 0, 20), # TO BE DEPRECATED -------------------------------------------- cutsDr = cms.vdouble(0.4, 0.4, 0.015), # TO BE DEPRECATED # parameters for attempting an L1 match using a propagator maxDeltaPhi = cms.double(0.4), # TO BE DEPRECATED maxDeltaR = cms.double(0.4), # TO BE DEPRECATED # TO BE DEPRECATED -------------------------------------------- # Definition of generic cuts on generated and reconstructed objects (note that # these cuts can be overloaded inside a particular analysis) # Objects recognized: Mu Ele Photon PFTau MET # Syntax in the strings: valid syntax of the StringCutObjectSelector class # --- Muons Mu_genCut = cms.string("pt > 10 && abs(eta) < 2.4 && abs(pdgId) == 13 && status == 1"), Mu_recCut = cms.string("pt > 10 && abs(eta) < 2.4 && isGlobalMuon"), Mu_cutMinPt = cms.double(10), # TO BE DEPRECATED Mu_cutMaxEta = cms.double(2.4), # TO BE DEPRECATED # --- Electrons Ele_genCut = cms.string("pt > 10 && abs(eta) < 2.5 && abs(pdgId) == 11 && status == 1"),
import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pyquen2016TmpSettingsEv4_cff import * generator = cms.EDFilter("HydjetGeneratorFilter", collisionParameters5020GeV, qgpParameters, hydjetParameters, hydjetMode = cms.string('kHydroQJets'), PythiaParameters = cms.PSet(pyquenPythiaDefaultBlock, # Quarkonia and Weak Bosons added back upon dilepton group's request. parameterSets = cms.vstring('pythiaUESettings', 'hydjetPythiaDefault', 'myParameters', 'pythiaJets', 'pythiaPromptPhotons', 'pythiaZjets', 'pythiaBottomoniumNRQCD', 'pythiaCharmoniumNRQCD', 'pythiaQuarkoniaSettings', 'pythiaWeakBosons' ) ), cFlag = cms.int32(1), bMin = cms.double(0), bMax = cms.double(30), bFixed = cms.double(0) )
descriptors = cms.vstring() ), cms.PSet( name = cms.string("MinSubleadingPFJetPt"), parameters = cms.vdouble(70.), descriptors = cms.vstring() ), cms.PSet( name = cms.string("PFDijetMaxDeltaEta"), parameters = cms.vdouble(1.3), descriptors = cms.vstring() ) ) ##-------------------- User analyzer -------------------------------- process.BHistograms = cms.EDAnalyzer('BTriggerEfficiency', file_names = input_files_vstring, tree_name = cms.string('ak5/ProcessedTree'), trigger_histogram_name = cms.string('ak5/TriggerNames'), data_source = cms.string('collision_data'), max_events = cms.int32(-1), dijet_cuts = dijet_cuts, pfjet_cuts = pfjet_cuts, calojet_cuts = calojet_cuts, event_cuts = event_cuts, fatjet_delta_eta_cut = cms.double(1.1), ) process.p = cms.Path(process.BHistograms)
'/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_32.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_320.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_321.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_322.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_323.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_324.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_325.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_326.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_327.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_328.root', '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_329.root' )) process.TFileService = cms.Service( "TFileService", fileName=cms.string("histogram_test_MB_AOD_10kevents.root")) process.demo = cms.EDAnalyzer( 'TestAnalysis', CentralitySrc=cms.InputTag("hiCentrality"), centralityBinLabel=cms.InputTag("centralityBin", "HFtowers"), srcTracks=cms.InputTag("hiGeneralTracks"), srcVertex=cms.InputTag("hiSelectedVertex"), UseQuality=cms.bool(True), TrackQuality=cms.string('highPurity'), trackEtaCut=cms.double(2.4), trackPtCut=cms.double(0.3), srcTracksPixel=cms.InputTag("hiGeneralAndPixelTracks")) process.p = cms.Path(process.centralityBin * process.demo)
addDiscriminators = True, addAssociatedTracks = True, addJetCharge = False, addJetID = False, getJetMCFlavour = True, addGenPartonMatch = True, addGenJetMatch = True, embedGenJetMatch = True, embedGenPartonMatch = True, # embedCaloTowers = False, # embedPFCandidates = True ) akSoftDrop6PFNjettiness = Njettiness.clone( src = cms.InputTag("akSoftDrop6PFJets"), R0 = cms.double(0.6) ) akSoftDrop6PFpatJetsWithBtagging.userData.userFloats.src += [ 'akSoftDrop6PFNjettiness:tau1', 'akSoftDrop6PFNjettiness:tau2', 'akSoftDrop6PFNjettiness:tau3'] akSoftDrop6PFJetAnalyzer = inclusiveJetAnalyzer.clone( jetTag = cms.InputTag("akSoftDrop6PFpatJetsWithBtagging"), genjetTag = 'ak6GenJets', rParam = 0.6, matchJets = cms.untracked.bool(False), matchTag = 'patJetsWithBtagging', pfCandidateLabel = cms.untracked.InputTag('particleFlow'), trackTag = cms.InputTag("generalTracks"),
from ForwardAnalysis.Utilities.trackMultiplicity_cfi import * trackMultiplicityTransverseRegion = trackMultiplicity.clone( src="tracksTransverseRegion") # # Systematic Studies # pfCandidatesShiftedUp = cms.EDProducer( "ShiftedPFCandidateProducer", src=cms.InputTag('particleFlow'), binning=cms.VPSet( cms.PSet( binSelection=cms.string('particleId == 0'), # particleId == X binUncertainty=cms.double(0.10)), cms.PSet( binSelection=cms.string('particleId == 1'), # particleId == h binUncertainty=cms.double(0.10)), cms.PSet( binSelection=cms.string('particleId == 2'), # particleId == e binUncertainty=cms.double(0.10)), cms.PSet( binSelection=cms.string('particleId == 3'), # particleId == mu binUncertainty=cms.double(0.10)), cms.PSet( binSelection=cms.string('particleId == 4'), # particleId == gamma binUncertainty=cms.double(0.10)), cms.PSet( binSelection=cms.string('particleId == 5'), # particleId == h0 binUncertainty=cms.double(0.10)),
CrossingAngle=TPCrossingAngle, BeamLineLengthCTPPS=TPBeamLineLengthCTPPS, #CTPPSSimHitProducer Z_Tracker1=ZTracker1Position, # first tracker z position in m Z_Tracker2=ZTracker2Position, Z_Timing=ZTimingPosition, #CTPPSRecHitProducer TrackerWidth=RecTrackerWidth, TrackerHeight=RecTrackerHeight, # tracker height in mm TrackerInsertion= RecTrackerInsertion, # Number of sigmas (X) from the beam for tracker insertion BeamXRMS_Trk1= RecBeamXRMS_Trk1, # beam size sigma(X) at first tracker station in mm BeamXRMS_Trk2= RecBeamXRMS_Trk2, # beam size sigma(X) at second tracker station in mm Trk1XOffset=RecTrk1XOffset, # insertion offset first tracker Trk2XOffset=RecTrk2XOffset, # insertion offset second tracker ToFCellWidth=RecToFCellWidth, #tofcell widths in mm - diamond ToFCellHeight=RecToFCellHeight, #tof height in mm ToFPitchX=RecToFPitchX, #cell pitch in X (in mm) ToFPitchY=RecToFPitchY, #cell pitch in Y (in mm) ToFNCellX=RecToFNCellX, # number of cells in X ToFNCellY=RecToFNCellY, # number of cells in Y ToFInsertion= RecToFInsertion, #Number of sigmas (X) from the beam for the tof insertion BeamXRMS_ToF=RecBeamXRMS_ToF, #beam size sigma(X) at ToF station in mm ToFXOffset=RecToFXOffset, #insertion offset ToF TimeSigma=RecTimeSigma, #in ns # ImpParcut=cms.double(0.6))
0.00000000E+00 3 1000022 2 -1 #dummy decay to enable off-shell W 0.33333333E+00 2 -1000011 12 0.33333333E+00 2 -1000013 14 0.33333333E+00 2 -1000015 16 DECAY 1000025 0.00000000E+00 # neutralino3 decays DECAY 1000035 0.00000000E+00 # neutralino4 decays DECAY 1000037 0.00000000E+00 # chargino2+ decays """ generator = cms.EDFilter( "Pythia8GeneratorFilter", 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.), RandomizedParameters=cms.VPSet(), ) model = "T8bbllnunu_XCha0p5" # weighted average of matching efficiencies for the full scan # must equal the number entered in McM generator params mcm_eff = 0.277 def matchParams(mass): if mass > 99 and mass < 199: return 62., 0.498 elif mass < 299: return 62., 0.361 elif mass < 399: return 62., 0.302 elif mass < 499: return 64., 0.275
VCaltoElectronGain_L1=cms.int32(65), VCaltoElectronOffset=cms.int32(-414), VCaltoElectronOffset_L1=cms.int32(-414), # ************************************** # **** payLoadType Options **** # **** HLT - column granularity **** # **** Offline - gain:col/ped:pix **** # ************************************** payloadType=cms.string('Offline'), #payloadType = cms.string('Full'), SeedThreshold=cms.int32(1000), ClusterThreshold=cms.int32(4000), ClusterThreshold_L1=cms.int32(4000), # ************************************** maxNumberOfClusters=cms.int32(-1), # -1 means no limit. ElectronPerADCGain=cms.double(135.0), AdcFullScaleStack=cms.int32(255), FirstStackLayer=cms.int32(5), Phase2Calibration=cms.bool(False), Phase2ReadoutMode=cms.int32(-1), Phase2DigiBaseline=cms.double(1200.), Phase2KinkADC=cms.int32(8), ) # phase1 pixel from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel phase1Pixel.toModify( siPixelClusters, VCaltoElectronGain=cms.int32(47), # L2-4: 47 +- 4.7 VCaltoElectronGain_L1=cms.int32(50), # L1: 49.6 +- 2.6 VCaltoElectronOffset=cms.int32(-60), # L2-4: -60 +- 130