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 custom_3dclustering_clusteringRadiusNoLayerDependenceVariableEta(process, distance_coefficientA=0.03, distance_coefficientB=0.02): parameters_c3d = process.hgcalBackEndLayer2Producer.ProcessorParameters.C3d_parameters parameters_c3d.dR_multicluster_byLayer_coefficientA = cms.vdouble( [distance_coefficientA]*(MAX_LAYERS+1) ) parameters_c3d.dR_multicluster_byLayer_coefficientB = cms.vdouble( [distance_coefficientB]*(MAX_LAYERS+1) ) return process
def jet(self) : jetJecFileName = 'Summer13_V5_DATA_UncertaintySources_AK5PFchs.txt' jetJecFile = os.popen('find . | grep %s | head -1' % jetJecFileName).read().strip() jetResFile = '%s/src/CondFormats/JetMETObjects/data/Spring10_PtResolution_AK5PF.txt'%os.environ['CMSSW_RELEASE_BASE'] self.process.tupleJet = cms.EDProducer("Tuple_PatJet", prefix = cms.string("jet"), jetsTag = tags("selectedPatJetsForAnalysis"), allJetsTag = tags("selectedPatJets"+self.options.postfix), jecRecord = cms.string("AK5PFchs"), jecNames = cms.vstring([""]+self.availableJecUncertainties()), bTags = cms.vstring(self.options.btags), pfInfo = cms.bool(True), genInfo = cms.bool( not self.options.isData), jetResolutionFile = cms.string(jetResFile.split('/')[-1]), jetUncertaintyFile = cms.string(jetJecFileName), # https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution resolutionRatioBins = cms.vdouble(0.0, 0.5, 1.1, 1.7, 2.3, 5.0), resolutionRatio = cms.vdouble(1.052, 1.057, 1.096, 1.134, 1.288), resolutionRatioErr = cms.vdouble( math.sqrt( 0.012**2 + 0.0615**2 ), math.sqrt( 0.012**2 + 0.0555**2 ), math.sqrt( 0.017**2 + 0.0625**2 ), math.sqrt( 0.035**2 + 0.086**2 ), math.sqrt( 0.127**2 + 0.154**2 ) ) ) os.system("cp %s ."%jetResFile) os.system("cp %s ."%jetJecFile) return self.empty + self.process.tupleJet
def customise_HcalPhase2(process): process = customise_HcalPhase1(process) if hasattr(process,'digitisation_step') and hasattr(process, 'mix'): # these are the new sampling factors, they reuse the old ones for # ieta < 21. For ieta greater than 21 it is using the function # samplingFraction = 188.441 + 0.834*eta # eta is the highest eta broundary of the ieta. This is currently # taken for HE from ieta 16 to 33 inclusive. Which would extend to # an eta of 3.0. For the option going to 4.0 it is unclear how many # ieta's there will be from 3 to 4, but this vector would need to be # extended. newFactors = cms.vdouble( 210.55, 197.93, 186.12, 189.64, 189.63, 189.96, 190.03, 190.11, 190.18, 190.25, 190.32, 190.40, 190.47, 190.54, 190.61, 190.69, 190.83, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94, 190.94) process.mix.digitizers.hcal.he.samplingFactors = newFactors process.mix.digitizers.hcal.he.photoelectronsToAnalog = cms.vdouble([10.]*len(newFactors)) if hasattr(process,'reconstruction_step'): process.towerMaker.HcalPhase = cms.int32(2) process.towerMakerPF.HcalPhase = cms.int32(2) process.towerMakerWithHO.HcalPhase = cms.int32(2) process.CaloTowerConstituentsMapBuilder.MapFile = cms.untracked.string("") return process
def unganged_me1a(process): ### CSC geometry customization: #from Configuration.StandardSequences.GeometryDB_cff import * if not process.es_producers_().has_key('idealForDigiCSCGeometry'): process.load('Geometry.CSCGeometryBuilder.cscGeometryDB_cfi') process.load('Geometry.CSCGeometryBuilder.idealForDigiCscGeometryDB_cff') process.CSCGeometryESModule.useGangedStripsInME1a = False process.idealForDigiCSCGeometry.useGangedStripsInME1a = False ### Digitizer customization: if 'simMuonCSCDigis' not in process.producerNames(): process.load('SimMuon.CSCDigitizer.muonCSCDigis_cfi') ## Make sure there's no bad chambers/channels #process.simMuonCSCDigis.strips.readBadChambers = True #process.simMuonCSCDigis.wires.readBadChannels = True #process.simMuonCSCDigis.digitizeBadChambers = True ## Customized timing offsets so that ALCTs and CLCTs times ## are centered in signal BX. The offsets below were tuned for the case ## of 3 layer pretriggering and median stub timing algorithm. process.simMuonCSCDigis.strips.bunchTimingOffsets = cms.vdouble(0.0, 37.53, 37.66, 55.4, 48.2, 54.45, 53.78, 53.38, 54.12, 51.98, 51.28) process.simMuonCSCDigis.wires.bunchTimingOffsets = cms.vdouble(0.0, 22.88, 22.55, 29.28, 30.0, 30.0, 30.5, 31.0, 29.5, 29.1, 29.88) #done return process
def addVariable(vpset,expr,name=None,nbins=None,vmin=None,vmax=None): if ":=" in expr: toks=[ v.rstrip(" ").lstrip(" ") for v in expr.split(":=") ] ## print toks name,expr=toks if not name: name = expr.replace(".","_").replace("get","") if name.endswith("]"): name,rng = name.replace("]","").split("[") rng = rng.split(",") nbins = int(rng[0]) vmin = float(rng[1]) vmax = float(rng[2]) if "map(" in expr: var, bins, vals = expr.lstrip("map(").rstrip(")").split("::") bins = [ float(b) for b in bins.split(",") ] vals = [ float(v) for v in vals.split(",") ] pset = cms.PSet( expr = cms.PSet( var = cms.string(var), bins = cms.vdouble(bins), vals = cms.vdouble(vals) ), name = cms.untracked.string(name), ) else: pset = cms.PSet( expr = cms.string(expr), name = cms.untracked.string(name), ) if nbins: pset.nbins = cms.untracked.int32(nbins) pset.vmin = cms.untracked.double(vmin) pset.vmax = cms.untracked.double(vmax) vpset.append(pset)
def 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 customise_Digi(process): if hasattr(process,'mix'): process.mix.digitizers.hcal.HBHEUpgradeQIE = True process.mix.digitizers.hcal.hb.siPMCells = cms.vint32([1]) process.mix.digitizers.hcal.hb.photoelectronsToAnalog = cms.vdouble([10.]*16) process.mix.digitizers.hcal.hb.pixels = cms.int32(4500*4*2) process.mix.digitizers.hcal.he.photoelectronsToAnalog = cms.vdouble([10.]*16) process.mix.digitizers.hcal.he.pixels = cms.int32(4500*4*2) process.mix.digitizers.hcal.HFUpgradeQIE = True process.mix.digitizers.hcal.HcalReLabel.RelabelHits=cms.untracked.bool(True) if hasattr(process,'HcalTPGCoderULUT'): process.HcalTPGCoderULUT.hcalTopologyConstants.mode=cms.string('HcalTopologyMode::SLHC') process.HcalTPGCoderULUT.hcalTopologyConstants.maxDepthHB=cms.int32(3) process.HcalTPGCoderULUT.hcalTopologyConstants.maxDepthHE=cms.int32(5) if hasattr(process,'simHcalDigis'): process.simHcalDigis.useConfigZSvalues=cms.int32(1) process.simHcalDigis.HBlevel=cms.int32(16) process.simHcalDigis.HElevel=cms.int32(16) process.simHcalDigis.HOlevel=cms.int32(16) process.simHcalDigis.HFlevel=cms.int32(16) process.digitisation_step.remove(process.simHcalTriggerPrimitiveDigis) process.digitisation_step.remove(process.simHcalTTPDigis) return process
def customiseFor15439(process): for producer in producers_by_type(process, "EgammaHLTBcHcalIsolationProducersRegional", "EgammaHLTEcalPFClusterIsolationProducer", "EgammaHLTHcalPFClusterIsolationProducer", "MuonHLTEcalPFClusterIsolationProducer", "MuonHLTHcalPFClusterIsolationProducer"): if hasattr(producer, "effectiveAreaBarrel") and hasattr(producer, "effectiveAreaEndcap"): if not hasattr(producer, "effectiveAreas") and not hasattr(producer, "absEtaLowEdges"): producer.absEtaLowEdges = cms.vdouble( 0.0, 1.479 ) producer.effectiveAreas = cms.vdouble( producer.effectiveAreaBarrel.value(), producer.effectiveAreaEndcap.value() ) del producer.effectiveAreaBarrel del producer.effectiveAreaEndcap return process
def HGCal_disableNoise(process): process.HGCAL_noise_fC = cms.PSet( values = cms.vdouble(0,0,0), #100,200,300 um ) process.HGCAL_noise_MIP = cms.PSet( value = cms.double(0) ) process.HGCAL_noises = cms.PSet( values = cms.vdouble(0,0,0) ) return process
def _modifyPixelDigitizerForRun2Bunchspacing50( digitizer ) : """ Function that modifies the pixel digitiser for Run 2 with 50ns bunchspacing. First argument is the pixelDigitizer object. """ # DynamicInefficency - 13TeV - 50ns case digitizer.theInstLumiScaleFactor = cms.double(246.4) digitizer.theLadderEfficiency_BPix1 = cms.vdouble( [0.979259,0.976677]*10 ) # This syntax makes a 20 element array of alternating numbers digitizer.theLadderEfficiency_BPix2 = cms.vdouble( [0.994321,0.993944]*16 ) digitizer.theLadderEfficiency_BPix3 = cms.vdouble( [0.996787,0.996945]*22 )
def makePSetForElectronGenericFilter(self, module, moduleName): # example usages of HLTElectronGenericFilter are: # deta filter hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDetaFilter # dphi filter hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDphiFilter # track isolation hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolTrackIsolFilter # the type of object to look for seems to be the # same for all uses of HLTEgammaGenericFilter theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerElectron) # infer the type of filter by the type of the producer which # generates the collection used to cut on this inputCollectionLabel = module.isoTag.moduleLabel inputType = getattr(self.process, inputCollectionLabel).type_() # print >> sys.stderr, "inputType=",inputType,moduleName # sanity check: non-isolated path should be produced by the # same type of module assert(inputType == getattr(self.process, module.nonIsoTag.moduleLabel).type_()) # the following cases seem to have identical PSets ? #-------------------- # deta and dphi filter #-------------------- # note that whether deta or dphi is used is determined from # the product instance (not the module label) if inputType == 'EgammaHLTElectronDetaDphiProducer': return cms.PSet( PlotBounds = cms.vdouble(0.0, 0.0), HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName), IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag), theHLTOutputTypes = theHLTOutputTypes ) #-------------------- # track isolation #-------------------- if inputType == 'EgammaHLTElectronTrackIsolationProducers': return cms.PSet( PlotBounds = cms.vdouble(0.0, 0.0), HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName), IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag), theHLTOutputTypes = theHLTOutputTypes ) raise Exception("can't determine what the HLTElectronGenericFilter '" + moduleName + "' should do: uses a collection produced by a module of C++ type '" + inputType + "'")
def addSemiLepKinFitMuon(process, isData=False) : ## std sequence to produce the kinematic fit for semi-leptonic events process.load("TopQuarkAnalysis.TopKinFitter.TtSemiLepKinFitProducer_Muons_cfi") #apply selections on muon process.cleanPatMuons.preselection = cms.string("pt>20 && abs(eta)<2.4"+ " && isGlobalMuon && isPFMuon && isTrackerMuon" + " && globalTrack.isNonnull "+ " && globalTrack.normalizedChi2<10"+ " && globalTrack.hitPattern.numberOfValidMuonHits>0"+ " && numberOfMatchedStations>1"+ " && innerTrack.hitPattern.numberOfValidPixelHits>0"+ " && track.hitPattern.trackerLayersWithMeasurement > 5"+ " && dB() < 0.2"+ " && (pfIsolationR04.sumChargedHadronPt+ max(0.,pfIsolationR04.sumNeutralHadronEt+pfIsolationR04.sumPhotonEt-0.5*pfIsolationR04.sumPUPt))/pt < 0.15" ) #clean jets from muons process.cleanPatJets.checkOverlaps.muons.requireNoOverlaps = cms.bool(True) process.cleanPatJets.preselection = cms.string("pt>15 && abs(eta)<2.5") #change constraints on kineFit process.kinFitTtSemiLepEvent.constraints = cms.vuint32(3, 4) process.kinFitTtSemiLepEvent.maxNJets = cms.int32(5) process.kinFitTtSemiLepEvent.jets = cms.InputTag("cleanPatJets") process.kinFitTtSemiLepEvent.leps = cms.InputTag("cleanPatMuons") #process.kinFitTtSemiLepEvent.mets = cms.InputTag("pfType1CorrectedMet") process.kinFitTtSemiLepEvent.mets = cms.InputTag("patMETsPF") process.kinFitTtSemiLepEvent.udscResolutions = udscResolutionPF.functions process.kinFitTtSemiLepEvent.bResolutions = bjetResolutionPF.functions process.kinFitTtSemiLepEvent.lepResolutions = muonResolution.functions process.kinFitTtSemiLepEvent.metResolutions = metResolutionPF.functions process.kinFitTtSemiLepEvent.metResolutions[0].eta = "9999" if not isData : process.kinFitTtSemiLepEvent.jetEnergyResolutionScaleFactors = cms.vdouble ( 1.052, 1.057, 1.096, 1.134, 1.288 ) process.kinFitTtSemiLepEvent.jetEnergyResolutionEtaBinning = cms.vdouble( 0.0, 0.5, 1.1, 1.7, 2.3, -1. ) # Add JES Up and Down and Rerun the KineFitter process.scaledJetEnergyUp = scaledJetEnergy.clone() process.scaledJetEnergyUp.inputJets = "cleanPatJets" process.scaledJetEnergyUp.inputMETs = "patMETsPF" process.scaledJetEnergyUp.scaleType = "jes:up" process.kinFitTtSemiLepEventJESUp = process.kinFitTtSemiLepEvent.clone() process.kinFitTtSemiLepEventJESUp.jets = cms.InputTag("scaledJetEnergyUp:cleanPatJets") process.kinFitTtSemiLepEventJESUp.mets = cms.InputTag("scaledJetEnergyUp:patMETsPF") process.scaledJetEnergyDown = scaledJetEnergy.clone() process.scaledJetEnergyDown.inputJets = "cleanPatJets" process.scaledJetEnergyDown.inputMETs = "patMETsPF" process.scaledJetEnergyDown.scaleType = "jes:down" process.kinFitTtSemiLepEventJESDown = process.kinFitTtSemiLepEvent.clone() process.kinFitTtSemiLepEventJESDown.jets = cms.InputTag("scaledJetEnergyDown:cleanPatJets") process.kinFitTtSemiLepEventJESDown.mets = cms.InputTag("scaledJetEnergyDown:patMETsPF") process.kinFitSequence = cms.Sequence(process.kinFitTtSemiLepEvent * process.scaledJetEnergyUp * process.kinFitTtSemiLepEventJESUp * process.scaledJetEnergyDown * process.kinFitTtSemiLepEventJESDown)
def HGCal_setEndOfLifeNoise(digitizer,process): process.HGCAL_noise_fC = cms.PSet( values = cms.vdouble( [x*fC_per_ele for x in endOfLifeNoises] ), #100,200,300 um ) process.HGCAL_chargeCollectionEfficiencies = cms.PSet( values = cms.vdouble(endOfLifeCCEs) ) process.HGCAL_noise_MIP = cms.PSet( value = cms.double( 1.0/5.0 ) ) process.HGCAL_noises = cms.PSet( values = cms.vdouble([x for x in endOfLifeNoises]) )
def tnpEffPSet(categories): effSet = cms.PSet() for category in categories: setattr( effSet, category + "_pt", cms.PSet( EfficiencyCategoryAndState=cms.vstring(category, "pass"), UnbinnedVariables=cms.vstring("mass"), BinnedVariables=cms.PSet( # pt = cms.vdouble(20, 25, 30, 35, 40, 50, 150), pt=cms.vdouble(20, 30, 40, 50, 150) ), BinToPDFmap=cms.vstring("vpvPlusQuadratic"), # vpvPlusExpo") ), ) setattr( effSet, category + "_abseta", cms.PSet( EfficiencyCategoryAndState=cms.vstring(category, "pass"), UnbinnedVariables=cms.vstring("mass"), BinnedVariables=cms.PSet( abseta=cms.vdouble(0.0, 0.5, 1.0, 1.4, 1.6, 2.0, 2.4) # abseta = cms.vdouble(0.0, 1.5, 2.4) ), BinToPDFmap=cms.vstring("vpvPlusExpo"), ), ) setattr( effSet, category + "_pt_abseta", cms.PSet( EfficiencyCategoryAndState=cms.vstring(category, "pass"), UnbinnedVariables=cms.vstring("mass"), BinnedVariables=cms.PSet( # pt = cms.vdouble(20, 25, 30, 35, 40, 50, 150), pt=cms.vdouble(20, 30, 40, 50, 150), abseta=cms.vdouble(0.0, 1.4, 1.6, 2.4) # abseta = cms.vdouble(0.0, 1.5, 2.4) ), BinToPDFmap=cms.vstring("vpvPlusExpo"), ), ) return effSet
def customizeForMETTriggerProducer (producer): producer.filterCategories = cms.vstring ( "met", "metClean", "metCleanBH", "mht", "pfMET", "pfMHT", "pfMETNoMu", "pfMHTNoMu", ) # The items in each vector correspond to the following triggers, in this order: # [HLT_MET200_v*, HLT_MET75_IsoTrk50_v*, HLT_PFMET100_PFMHT100_IDTight_BeamHaloCleaned_v*, HLT_PFMET120_PFMHT120_IDTight_v*, HLT_PFMET170_HBHECleaned_v*, HLT_PFMET300_v*, HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v*] producer.metCollections = cms.vstring ("hltMet::HLT", "hltMet::HLT", "hltMet::HLT", "hltMet::HLT", "hltMet::HLT", "hltMet::HLT", "hltMet::HLT") producer.metThresholds = cms.vdouble (200.0, 75.0, 80.0, 90.0, 90.0, 90.0, 90.0) producer.metJetsForTag = cms.vstring ("", "", "", "", "", "", "") producer.metMuonsCountedAsVisible = cms.bool (False) producer.metCleanCollections = cms.vstring ("hltMetClean::HLT", "hltMetClean::HLT", "hltMetClean::HLT", "hltMetClean::HLT", "hltMetClean::HLT", "hltMetClean::HLT", "hltMetClean::HLT") producer.metCleanThresholds = cms.vdouble (190.0, 65.0, 70.0, 80.0, 80.0, 80.0, 80.0) producer.metCleanJetsForTag = cms.vstring ("", "", "", "", "", "", "") producer.metCleanMuonsCountedAsVisible = cms.bool (False) producer.metCleanBHCollections = cms.vstring ("", "", "hltMetCleanBH::HLT", "", "", "", "") producer.metCleanBHThresholds = cms.vdouble (0.0, 0.0, 70.0, 0.0, 0.0, 0.0, 0.0) producer.metCleanBHJetsForTag = cms.vstring ("", "", "", "", "", "", "") producer.metCleanBHMuonsCountedAsVisible = cms.bool (False) producer.mhtCollections = cms.vstring ("", "", "hltMht::HLT", "hltMht::HLT", "", "", "hltMht::HLT") producer.mhtThresholds = cms.vdouble (0.0, 0.0, 80.0, 90.0, 0.0, 0.0, 90.0) producer.mhtJetsForTag = cms.vstring ("", "", "hltAK4CaloJetsCorrectedIDPassed::HLT", "hltAK4CaloJetsCorrectedIDPassed::HLT", "", "", "hltAK4CaloJetsCorrectedIDPassed::HLT") producer.mhtMuonsCountedAsVisible = cms.bool (False) producer.pfMETCollections = cms.vstring ("", "", "hltPFMETProducer::HLT", "hltPFMETProducer::HLT", "hltPFMETProducer::HLT", "hltPFMETProducer::HLT", "") producer.pfMETThresholds = cms.vdouble (0.0, 0.0, 100.0, 120.0, 170.0, 300.0, 0.0) producer.pfMETJetsForTag = cms.vstring ("", "", "", "", "", "", "") producer.pfMETMuonsCountedAsVisible = cms.bool (True) producer.pfMHTCollections = cms.vstring ("", "", "hltPFMHTTightID::HLT", "hltPFMHTTightID::HLT", "", "", "") producer.pfMHTThresholds = cms.vdouble (0.0, 0.0, 100.0, 120.0, 0.0, 0.0, 0.0) producer.pfMHTJetsForTag = cms.vstring ("", "", "hltAK4PFJetsTightIDCorrected::HLT", "hltAK4PFJetsTightIDCorrected::HLT", "", "", "") producer.pfMHTMuonsCountedAsVisible = cms.bool (True) producer.pfMETNoMuCollections = cms.vstring ("", "", "", "", "", "", "hltPFMETNoMuProducer::HLT") producer.pfMETNoMuThresholds = cms.vdouble (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 120.0) producer.pfMETNoMuJetsForTag = cms.vstring ("", "", "", "", "", "", "") producer.pfMETNoMuMuonsCountedAsVisible = cms.bool (False) producer.pfMHTNoMuCollections = cms.vstring ("", "", "", "", "", "", "hltPFMHTNoMuTightID::HLT") producer.pfMHTNoMuThresholds = cms.vdouble (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 120.0) producer.pfMHTNoMuJetsForTag = cms.vstring ("", "", "", "", "", "", "hltAK4PFJetsTightIDCorrected::HLT") producer.pfMHTNoMuMuonsCountedAsVisible = cms.bool (False) producer.additionalCollections = cms.vstring ("", "hltTrk50Filter::HLT", "", "", "", "", "") producer.additionalFilters = cms.vstring ("", "hltTrk50Filter", "", "", "", "", "") return producer
def tnpEffPSet(categories): effSet = cms.PSet() for category in categories: setattr(effSet, category+"_pt", cms.PSet( EfficiencyCategoryAndState = cms.vstring(category, "pass"), UnbinnedVariables = cms.vstring("mass","weight"), BinnedVariables = cms.PSet( #pt = cms.vdouble(20, 25, 30, 35, 40, 50, 150), pt = cms.vdouble(5,10,15,20, 30, 40, 50, 150), ), BinToPDFmap = cms.vstring("bwResCBExp") #vpvPlusExpo") )) setattr(effSet, category+"_abseta", cms.PSet( EfficiencyCategoryAndState = cms.vstring(category, "pass"), UnbinnedVariables = cms.vstring("mass","weight"), BinnedVariables = cms.PSet( abseta = cms.vdouble(0.0, 0.9, 1.2, 2.5) #abseta = cms.vdouble(0.0, 0.5, 1.0, 1.4, 1.6, 2.0, 2.4) #abseta = cms.vdouble(0.0, 1.5, 2.4) ), BinToPDFmap = cms.vstring("bwResCBExp") )) setattr(effSet, category+"_pt_abseta", cms.PSet( EfficiencyCategoryAndState = cms.vstring(category, "pass"), UnbinnedVariables = cms.vstring("mass","weight"), BinnedVariables = cms.PSet( #pt = cms.vdouble(20, 25, 30, 35, 40, 50, 150), pt = cms.vdouble(5,10,15,20, 30, 40, 50, 150), abseta = cms.vdouble(0.0, 0.9, 1.2, 2.5) #abseta = cms.vdouble(0.0, 1.5, 2.4) ), BinToPDFmap = cms.vstring("bwResCBExp") #"vpvPlusExpo") )) setattr(effSet, category+"_event_nPV", cms.PSet( EfficiencyCategoryAndState = cms.vstring(category, "pass"), UnbinnedVariables = cms.vstring("mass", "weight"), BinnedVariables = cms.PSet( #abseta = cms.vdouble(0.0, 1.5, 2.4) event_nPV = cms.vdouble(*[i-0.5 for i in range(0, 32)]), ), BinToPDFmap = cms.vstring("bwResCBExp") )) return effSet
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 makePSetForPixelMatchFilter(self, moduleName): return cms.PSet( PlotBounds = cms.vdouble(0.0, 0.0), HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName), IsoCollections = cms.VInputTag(cms.InputTag("none")), theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerCluster) )
def setPileupWeightFor2010(pset=vertexWeight): # From Apr21 JSON pset.mcDist = mix_E7TeV_FlatDist10_2011EarlyData_50ns_PoissonOOT pset.dataDist = cms.vdouble() pset.enabled = True pset.useSimulatedPileup = True raise Exception("Data PU distribution for 2010 is not yet available")
def _evenBins(min,max,delta): ret = cms.vdouble(min) x = min while x < max - 1e-4: # need a small hint otherwise for some numbers it will overstep due to numerical resolution x += delta ret.append(x) return ret
def custom_3dclustering_clusteringRadiusLayerbyLayerFixedEta(process, distance_coefficientA = dr_layerbylayer): parameters_c3d = process.hgcalBackEndLayer2Producer.ProcessorParameters.C3d_parameters parameters_c3d.dR_multicluster_byLayer_coefficientA = distance_coefficientA parameters_c3d.dR_multicluster_byLayer_coefficientB = cms.vdouble( [0]*(MAX_LAYERS+1) ) return process
def customise(process): print "Add " print "process.local = cms.PSet() # for local running " if hasattr(process, "local"): print "#########################################################" print " local run!" print "#########################################################" print print print base = "file:/scratch/scratch0/tfruboes/DATA_tmp/RelValMinBias/CMSSW_4_2_0_pre4-MC_42_V1-v1/GEN-SIM-DIGI-RAW-HLTDEBUG/" process.mix.input.fileNames = cms.untracked.vstring( base + "4C824492-2639-E011-9506-001A928116F0.root", base + "9ED6309B-C238-E011-A1D6-003048678ADA.root", base + "487A3591-CA38-E011-92A8-00248C0BE013.root", base + "0E5A4D31-BD38-E011-93B7-0026189437F2.root", ) process.mix.input.nbPileupEvents.probFunctionVariable = cms.vint32() process.mix.input.nbPileupEvents.probValue = cms.vdouble() # print dir(process.mix.input.nbPileupEvents.probValue) for i in range(0, 51): process.mix.input.nbPileupEvents.probFunctionVariable.append(i) val = 0.25 if i == 0 or i == 9 or i == 19 or i == 29: # val=1 # if i==0: process.mix.input.nbPileupEvents.probValue.append(val) else: process.mix.input.nbPileupEvents.probValue.append(0.0) return process
def __init__(self): self.parResolFix = cms.vint32() self.parResolOrder = cms.vint32() self.parResol = cms.vdouble() self.parResolStep = cms.untracked.vdouble() self.parResolMin = cms.untracked.vdouble() self.parResolMax = cms.untracked.vdouble()
def 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 neutronBG(process): # common fragment allowing to simulate neutron background in muon system if hasattr(process,'g4SimHits'): # time window 10 second TimeCut = cms.double(10000000000.0) process.common_maximum_time.MaxTrackTime = TimeCut process.common_maximum_time.DeadRegions = cms.vstring() # Physics List XS process.g4SimHits.Physics.type = cms.string('SimG4Core/Physics/FTFP_BERT_XS_EML') process.g4SimHits.Physics.CutsOnProton = cms.untracked.bool(False) process.g4SimHits.Physics.FlagFluo = cms.bool(True) process.g4SimHits.Physics.ThermalNeutrons = cms.untracked.bool(False) # Eta cut process.g4SimHits.Generator.MinEtaCut = cms.double(-7.0) process.g4SimHits.Generator.MaxEtaCut = cms.double(7.0) # stacking action process.g4SimHits.StackingAction.MaxTrackTime = TimeCut process.g4SimHits.StackingAction.DeadRegions = cms.vstring() process.g4SimHits.StackingAction.GammaThreshold = cms.double(0.0) # stepping action process.g4SimHits.SteppingAction.MaxTrackTime = TimeCut process.g4SimHits.SteppingAction.DeadRegions = cms.vstring() # Russian roulette disabled process.g4SimHits.StackingAction.RusRoGammaEnergyLimit = cms.double(0.0) process.g4SimHits.StackingAction.RusRoNeutronEnergyLimit = cms.double(0.0) # Calorimeter hits process.g4SimHits.CaloSD.TmaxHit = TimeCut process.g4SimHits.CaloSD.TmaxHits = cms.vdouble(10000000000,10000000000,10000000000,10000000000,10000000000) # full simulation of HF process.g4SimHits.HCalSD.UseShowerLibrary = cms.bool(False) process.g4SimHits.HFShower.UseShowerLibrary = cms.bool(False) return(process)
def setVertexWeightFor2010(pset=vertexWeight): # From runs 136035-149294 single tau trigger and W+jet #vertexWeight.weights = cms.vdouble(0.00000, 3.66926, 3.00360, 1.39912, 0.50035, 0.15271, 0.04164, 0.01124, 0.00293, 0.00083, 0.00022, 0.00006, 0.00000) # From runs 136035-149294 single tau trigger and QCD, vertex sumpt > 10 pset.weights = cms.vdouble(0.09267533, 2.24385810, 1.55092120, 0.59239078, 0.17919108, 0.04978977, 0.01336043, 0.00359282, 0.00072334, 0.00017415, 0.00000000) pset.enabled = True pset.useSimulatedPileup = False
def setVertexWeightFor2011(pset=vertexWeight): # From runs 160431-162828 single tau trigger and W+jets #vertexWeight.weights = cms.vdouble(0.00000, 0.24846, 0.88677, 1.52082, 1.79081, 1.53684, 1.08603, 0.71142, 0.45012, 0.27843, 0.17420, 0.13067, 0.08622, 0.04736, 0.03079, 0.14548, 0.00000) # From runs 160431-162828 single tau trigger and W+jets, vertex sumpt > 10 pset.weights = cms.vdouble(0.03445398, 0.76995593, 1.36990047, 1.32346773, 0.96835577, 0.63931763, 0.41220802, 0.25240105, 0.15958929, 0.11445294, 0.07332379, 0.10596101, 0.00000000) pset.enabled = True pset.useSimulatedPileup = False
def customise_Digi(process): process=digiEventContent(process) process.mix.digitizers.hcal.ho.photoelectronsToAnalog = cms.vdouble([4.0]*16) process.mix.digitizers.hcal.ho.siPMCode = cms.int32(1) process.mix.digitizers.hcal.ho.pixels = cms.int32(2500) process.mix.digitizers.hcal.ho.doSiPMSmearing = cms.bool(False) return process
def digitizer_timing_pre3_median(process): ## Make sure there's no bad chambers/channels #process.simMuonCSCDigis.strips.readBadChambers = True #process.simMuonCSCDigis.wires.readBadChannels = True #process.simMuonCSCDigis.digitizeBadChambers = True ## Customized timing offsets so that ALCTs and CLCTs times are centered in signal BX. ## These offsets below were tuned for the case of 3 layer pretriggering ## and median stub timing algorithm. process.simMuonCSCDigis.strips.bunchTimingOffsets = cms.vdouble(0.0, 37.53, 37.66, 55.4, 48.2, 54.45, 53.78, 53.38, 54.12, 51.98, 51.28) process.simMuonCSCDigis.wires.bunchTimingOffsets = cms.vdouble(0.0, 22.88, 22.55, 29.28, 30.0, 30.0, 30.5, 31.0, 29.5, 29.1, 29.88) return process
process.load("Validation.HcalRecHits.HcalRecHitParam_cfi") process.load("Validation.CaloTowers.CaloTowersParam_cfi") process.calotowersAnalyzer.outputFile = cms.untracked.string( 'CaloTowersValidationRelVal.root') #--- replace hbhereco with hbheprereco delattr(process, "hbhereco") process.hbhereco = process.hbheprereco.clone() process.hcalLocalRecoSequence = cms.Sequence(process.hbhereco + process.hfprereco + process.hfreco + process.horeco) #--- post-LS1 customization process.mix.digitizers.hcal.minFCToDelay = cms.double(5.) # new TS model process.mix.digitizers.hcal.ho.photoelectronsToAnalog = cms.vdouble([4.0] * 16) process.mix.digitizers.hcal.ho.siPMCode = cms.int32(1) process.mix.digitizers.hcal.ho.pixels = cms.int32(2500) process.mix.digitizers.hcal.ho.doSiPMSmearing = cms.bool(False) process.mix.digitizers.hcal.hf1.samplingFactor = cms.double(0.67) process.mix.digitizers.hcal.hf2.samplingFactor = cms.double(0.67) process.g4SimHits.HFShowerLibrary.FileName = 'SimG4CMS/Calo/data/HFShowerLibrary_npmt_noatt_eta4_16en_v4.root' #---------- PATH # -- NB: for vertex smearing the Label should be: "unsmeared" # for GEN produced since 760pre6, for older GEN - just "": process.VtxSmeared.src = cms.InputTag("generator", "") process.generatorSmeared = cms.EDProducer("GeneratorSmearedProducer") process.g4SimHits.Generator.HepMCProductLabel = 'VtxSmeared' process.p = cms.Path(
probValue = cms.vdouble( 0, 9.62366e-05, 0.000114197, 0.000134913, 0.000231518, 0.00060477, 0.000293912, 0.000498086, 0.000428207, 0.000397567, 0.000673966, 0.000921706, 0.000939553, 0.00123681, 0.00134677, 0.0013111, 0.00129396, 0.00123714, 0.00134814, 0.00160606, 0.00192138, 0.00233791, 0.00267774, 0.00280918, 0.0031197, 0.0043562, 0.00751272, 0.0136892, 0.0231778, 0.0345168, 0.0449839, 0.0523745, 0.0562289, 0.0574614, 0.0572404, 0.0563041, 0.0549491, 0.0532784, 0.0513576, 0.0492327, 0.0469169, 0.0443847, 0.0415475, 0.0382496, 0.0343446, 0.0298547, 0.0250429, 0.0203144, 0.0160256, 0.0123618, 0.00935279, 0.00695715, 0.00511836, 0.00377423, 0.00284529, 0.0022352, 0.00184568, 0.00159325, 0.0014179, 0.00128249, 0.00116709, 0.00106237, 0.000964582, 0.000872513, 0.000785909, 0.00070481, 0.000629288, 0.000559369, 0.000495015, 0.000436122, 0.000382531, 0.000334038, 0.000290399, 0.000251341, 0.000216572, 0.000185785, 0.000158667, 0.000134907, 0.000114197, 9.62366e-05, 8.07416e-05, 6.74411e-05, 5.60817e-05, 4.64288e-05, 3.8267e-05, 3.14001e-05, 2.56511e-05, 2.08618e-05, 1.68915e-05, 1.36161e-05, 1.09272e-05, 8.73039e-06, 6.9443e-06, 5.49912e-06, 4.33538e-06, 3.40276e-06, 2.65892e-06, 2.06847e-06, 1.602e-06, 1.23523e-06),
### Reference: https://github.com/khaosmos93/CMSPhase2MuonHLT/blob/master/example_cfgs/HLT_Phase2_example_menu.py ### Set the L1Tracks explicitly process.L1TkMuons.L1TrackInputTag = cms.InputTag( "TTTracksFromTrackletEmulation", "Level1TTTracks", "RECO") ### Apply quality cuts by default process.L1TkMuons.applyQualityCuts = cms.bool(True) process.hltL1TkSingleMuFiltered22 = cms.EDFilter( "L1TTkMuonFilter", MaxEta=cms.double(2.4), MinEta=cms.double(-2.4), MinN=cms.int32(1), MinPt=cms.double(22.0), Scalings=cms.PSet( barrel=cms.vdouble(0.820128, 1.04124, 0.0), endcap=cms.vdouble(0.864715, 1.03215, 0.0), overlap=cms.vdouble(0.920897, 1.03712, 0.0), ), inputTag=cms.InputTag("L1TkMuons", "", "L1TSkimming"), saveTags=cms.bool(True), ) process.hltL1TkSingleMuFiltered15 = cms.EDFilter( "L1TTkMuonFilter", MaxEta=cms.double(2.4), MinEta=cms.double(-2.4), MinN=cms.int32(1), MinPt=cms.double(15.0), Scalings=cms.PSet( barrel=cms.vdouble(0.820128, 1.04124, 0.0),
) modelBinner3mZbins = cms.PSet( pluginName = cms.string('modelBinner3mZbins'), pluginType = cms.string('ModelBinner'), binning = cms.PSet( name = cms.string("modelBinning3mZbins"), config = cms.VPSet( cms.PSet( extractor = cms.PSet( pluginType = cms.string("PATMuTauPairValExtractor"), src = cms.InputTag(''), value = cms.string("nSVfitSolution('psKine_MEt_logM_fit').mass()") ), binning = cms.PSet( boundaries = cms.vdouble(20., 60., 120.), min = cms.double(-1.01), max = cms.double(1000.) ) ) ) ), genBinning = cms.PSet( config = cms.VPSet( cms.PSet( extractor = cms.PSet( pluginType = cms.string("CandidateValExtractor"), src = cms.InputTag('genZdecayToTaus'), value = cms.string("mass()") ) )
print "[BHistograms_BJetPlusX_loose] ERROR : dataType must be data, signal, or background" sys.exit(1) process = cms.Process("myprocess") process.TFileService = cms.Service("TFileService", fileName=cms.string(options.outputFile)) ##-------------------- Define the source ---------------------------- process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(1)) process.source = cms.Source("EmptySource") ##-------------------- Cuts ------------------------------------------ # Cuts on the leading two jets dijet_cuts = cms.VPSet( cms.PSet(name=cms.string("MinPt"), parameters=cms.vdouble(30.), descriptors=cms.vstring()), cms.PSet(name=cms.string("MaxAbsEta"), parameters=cms.vdouble(2.2), descriptors=cms.vstring()), cms.PSet(name=cms.string("IsTightID"), parameters=cms.vdouble(), descriptors=cms.vstring()), cms.PSet(name=cms.string("MaxMuonEnergyFraction"), parameters=cms.vdouble(0.8), descriptors=cms.vstring()), ) # Cuts on all PF jets (defines the generic jet collection for e.g. making fat jets) pfjet_cuts = cms.VPSet( cms.PSet(name=cms.string("MinPt"),
# RPDigiProducer ROUList=cms.vstring('TotemHitsRP'), RPVerbosity=cms.int32(0), RPDigiSimHitRelationsPresistence=cms.bool( False), # save links betweend digi, clusters and OSCAR/Geant4 hits # RPDetDigitizer RPEquivalentNoiseCharge300um=cms.double(1000.0), RPNoNoise=cms.bool(False), # RPDisplacementGenerator RPDisplacementOn=cms.bool(False), # RPLinearChargeCollectionDrifter RPGeVPerElectron=cms.double(3.61e-09), RPInterStripSmearing=cms.vdouble(0.011), # RPLinearChargeDivider RPLandauFluctuations=cms.bool(True), RPChargeDivisionsPerStrip=cms.int32(15), RPChargeDivisionsPerThickness=cms.int32(5), RPDeltaProductionCut=cms.double(0.120425), # [MeV] # RPLinearInduceChargeOnStrips RPInterStripCoupling=cms.double( 1.0 ), # fraction of charge going to the strip, the missing part is taken by its neighbours # RPVFATSimulator RPVFATTriggerMode=cms.int32(2), RPVFATThreshold=cms.double(9000.0),
background_cdf = make_cdf(background_histo) transform = lambda x: compute_transform(x, signal_cdf, signal_scale, background_cdf, background_scale) npoints = 1000 for ix in range(npoints): x = min + ix*(max-min)*1.0/npoints transform_result = transform(x) transform_values.append(transform_result['transform']) # Check if this is one of our cuts if thresholds and transform_result['signal_passing'] < thresholds[0]: print("***********") print(x, transform_result) thresholds.pop(0) threshold_values.append((x, transform_result['transform'])) output_object.transform = cms.vdouble(transform_values) # Store information about the weight of this decay mode for signal output_object.signalDecayModeWeight = cms.double(signal_scale) output_object.backgroundDecayModeWeight = cms.double(background_scale) print(threshold_values) # On the chance that a decay mode has nothing in it if not threshold_values: threshold_values = [(-1,-1)]*3 # Store the loose medium and tight cut thresholds output_object.looseCutRaw = cms.double(threshold_values[0][0]) output_object.looseCut = cms.double(threshold_values[0][1]) output_object.mediumCutRaw = cms.double(threshold_values[1][0]) output_object.mediumCut = cms.double(threshold_values[1][1]) output_object.tightCutRaw = cms.double(threshold_values[2][0])
input=cms.SecSource( "EmbeddedRootSource", type=cms.string('probFunction'), nbPileupEvents=cms.PSet( probFunctionVariable=cms.vint32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49), probValue=cms.vdouble( 0.000108643, 0.000388957, 0.000332882, 0.00038397, 0.000549167, 0.00105412, 0.00459007, 0.0210314, 0.0573688, 0.103986, 0.142369, 0.157729, 0.147685, 0.121027, 0.08855, 0.0582866, 0.0348526, 0.019457, 0.0107907, 0.00654313, 0.00463195, 0.00370927, 0.0031137, 0.00261141, 0.00215499, 0.00174491, 0.00138268, 0.00106731, 0.000798828, 0.00057785, 0.00040336, 0.00027161, 0.000176535, 0.00011092, 6.75502e-05, 4.00323e-05, 2.32123e-05, 1.32585e-05, 7.51611e-06, 4.25902e-06, 2.42513e-06, 1.39077e-06, 8.02452e-07, 4.64159e-07, 2.67845e-07, 1.5344e-07, 8.68966e-08, 4.84931e-08, 2.6606e-08, 1.433e-08), histoFileName=cms.untracked.string('histProbFunction.root'), ), sequential=cms.untracked.bool(False), manage_OOT=cms.untracked.bool(True), ## manage out-of-time pileup ## setting this to True means that the out-of-time pileup ## will have a different distribution than in-time, given ## by what is described on the next line: OOT_type=cms.untracked.string( 'Poisson' ), ## generate OOT with a Poisson matching the number chosen for in-time
import FWCore.ParameterSet.Config as cms btvObjects = cms.VPSet( cms.PSet( pathNAME=cms.string( "HLT_DoubleJets100_DoubleBTagCSV_0p92_DoublePFJets128MaxDeta1p6"), moduleNAME=cms.string("hltBTagCalo80x6CSVp0p92DoubleWithMatching"), label=cms.string("CALO b-jet (double)"), xTITLE=cms.string("CALO b-jet"), etaBINNING=cms.vdouble(-2.5, -2.0, -1.5, -1.0, -0.5, 0., 0.5, 1.0, 1.5, 2.0, 2.5), ptBINNING=cms.vdouble(0., 50., 60., 70., 80., 90., 100., 110., 120., 130., 140., 150., 160., 170., 180., 190., 200., 250., 300., 400., 500.), phiBINNING=cms.vdouble(-3.2, -3., -2.8, -2.6, -2.4, -2.2, -2.0, -1.8, -1.6, -1.4, -1.2, -1.0, -0.8, -0.6, -0.4, -0.2, 0., 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.2), massBINNING=cms.vdouble(), dxyBINNING=cms.vdouble(), dzBINNING=cms.vdouble(), dimassBINNING=cms.vdouble(0., 50., 60., 70., 80., 90., 100., 110., 120., 130., 140., 150., 200., 250., 300., 400., 500.), displayInPrimary_eta=cms.bool(True), displayInPrimary_phi=cms.bool(True), displayInPrimary_pt=cms.bool(True), displayInPrimary_mass=cms.bool(False), displayInPrimary_energy=cms.bool(False), displayInPrimary_csv=cms.bool(True), displayInPrimary_etaVSphi=cms.bool(True),
# # Label for the input collection of Candidate objects src=cms.InputTag("towerMaker"), # # Label for the jets. Vertex correction may be done for "CaloJet" only. jetType=cms.string("CaloJet"), # # Perform vertex correction? doPVCorrection=cms.bool(False), # # Label for the input collection of vertex objects. Meaningful # only when "doPVCorrection" is True srcPVs=cms.InputTag("offlinePrimaryVertices"), # # Eta-dependent magnitude factors for the data (applied before filtering) etaDependentMagnutideFactors=cms.vdouble(), # # Eta-dependent magnitude factors for the data (applied after filtering) etaFlatteningFactors=cms.vdouble(calo_ps.fftjet_pileup_magnitude_factors), # # Configuration for the energy discretization grid GridConfiguration=fftjet_pileup_grid_calo, # # Convolution range convolverMinBin=cms.uint32(calo_ps.fftjet_pileup_min_eta_bin), convolverMaxBin=cms.uint32(calo_ps.fftjet_pileup_max_eta_bin), # # Conversion factor from the Et sum to the Et density pileupEtaPhiArea=cms.double(calo_ps.fftjet_pileup_eta_phi_area), # # The set of scales used by the filters. Here, just one scale
src = cms.InputTag("onia2MuMuPatTrkTrk"), srcWithCaloMuons = cms.InputTag("onia2MuMuPatGlbCal"), writeTree = cms.bool(True), treeFileName = cms.string("onia2MuMu_tree.root"), #treeFileName = cms.string("OUTPUTFILE1"), writeDataSet = cms.bool(True), dataSetName = cms.string("dataSet.root"), #dataSetName = cms.string("OUTPUTFILE2"), triggersForDataset = cms.vstring("HLT_Dimuon10_Jpsi_Barrel_v5"), massMin = cms.double(2.6), massMax = cms.double(3.5), pTBinRanges = cms.vdouble(0.0, 6.0, 8.0, 9.0, 10.0, 12.0, 15.0, 40.0), etaBinRanges = cms.vdouble(0.0, 1.3, 2.5), onlyTheBest = cms.bool(True), applyCuts = cms.bool(True), applyExpHitCuts = cms.untracked.bool(False), applyDiMuonCuts = cms.untracked.bool(False), #H: useBeamSpot = cms.bool(False), useCaloMuons = cms.untracked.bool(False), removeSignalEvents = cms.untracked.bool(False), removeTrueMuons = cms.untracked.bool(False), writeOutCandidates = cms.untracked.bool(False), massCorrectionMode = cms.int32(3), # mode 0 no correction, # mode 1 constant corr, # mode 2 pt dependent corr, # mode 3 pt and eta dependent corr oniaPDG = cms.int32(443),
Verbosity=cms.untracked.int32(0)) process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(100000)) process.TFileService = cms.Service("TFileService", fileName=cms.string('matbdg_Fwd.root')) process.p1 = cms.Path(process.generator * process.g4SimHits) process.g4SimHits.UseMagneticField = False process.g4SimHits.Physics.type = 'SimG4Core/Physics/DummyPhysics' process.g4SimHits.Physics.DummyEMPhysics = True process.g4SimHits.Physics.CutsPerRegion = False process.g4SimHits.Generator.ApplyEtaCuts = False process.common_maximum_timex = cms.PSet(MaxTrackTime=cms.double(1000.0), MaxTimeNames=cms.vstring(), MaxTrackTimes=cms.vdouble()) process.g4SimHits.StackingAction = cms.PSet( process.common_heavy_suppression, process.common_maximum_timex, KillDeltaRay=cms.bool(True), TrackNeutrino=cms.bool(False), KillHeavy=cms.bool(False), SaveFirstLevelSecondary=cms.untracked.bool(True), SavePrimaryDecayProductsAndConversionsInTracker=cms.untracked.bool(True), SavePrimaryDecayProductsAndConversionsInCalo=cms.untracked.bool(True), SavePrimaryDecayProductsAndConversionsInMuon=cms.untracked.bool(True)) process.g4SimHits.SteppingAction = cms.PSet( process.common_maximum_timex, KillBeamPipe=cms.bool(False), CriticalEnergyForVacuum=cms.double(0.0),
import FWCore.ParameterSet.Config as cms minEtaCorrection = cms.double(1.4) maxEtaCorrection = cms.double(3.0) hadronCorrections = cms.vdouble(1.16, 1.10, 1.08, 1.08, 1.09, 1.11, 1.14, 1.26) egammaCorrections = cms.vdouble(1.00, 1.00, 1.00, 1.00, 1.02, 1.03, 1.03, 1.03)
import FWCore.ParameterSet.Config as cms # configuration to model pileup for initial physics phase # Now, import base configuration instead of specfiying all parameters from SimGeneral.MixingModule.mix_probFunction_25ns_PoissonOOTPU_cfi import * mix.input.nbPileupEvents.probFunctionVariable = cms.vint32( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), mix.input.nbPileupEvents.probValue = cms.vdouble( 0.862811884308912, 0.122649088500652, 0.013156023430157, 0.001271967352346, 0.000100080253829, 8.21711557752311E-06, 1.47486689852979E-06, 2.10695271218541E-07, 2.10695271218541E-07, 2.10695271218541E-07, 2.10695271218541E-07, 2.10695271218541E-07, 2.10695271218541E-07)
from SimGeneral.MixingModule.digitizers_cfi import * mix = cms.EDProducer( "MixingModule", digitizers=cms.PSet(theDigitizers), LabelPlayback=cms.string(''), maxBunch=cms.int32(-2), ## all bunches come 75 ns early minBunch=cms.int32(-2), ## in terms of 25 nsec bunchspace=cms.int32(25), ##ns mixProdStep1=cms.bool(False), mixProdStep2=cms.bool(False), playback=cms.untracked.bool(False), useCurrentProcessOnly=cms.bool(False), input=cms.SecSource( "EmbeddedRootSource", type=cms.string('probFunction'), nbPileupEvents=cms.PSet( probFunctionVariable=cms.vint32(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24), probValue=cms.vdouble(0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.04593, 0.01965, 0.00953, 0.00440, 0.00196), histoFileName=cms.untracked.string('histProbFunction.root'), ), sequential=cms.untracked.bool(False), fileNames=FileNames), mixObjects=cms.PSet(theMixObjects))
sigmaGlobalShiftXY=cms.untracked.double(2.0), sigmaGlobalThetaXY=cms.untracked.double(0.003), verbosity=cms.untracked.bool(False), inputFileNameMisal=cms.untracked.string( 'SimTotem/T2Digitizer/test/testMisal.txt')), stripHit=cms.PSet( # diffCoeff = cms.double(0.26), # diffusion coefficient of driftzone NUMBER_OF_SIM_STEPS=cms.int32( 30), # number of uniformly distributed electron-hole pairs eIonE=cms.double(28.0), # Energy to create electron/ionpair #gain = cms.double(8000.0), # Gain of GEM detector z_max=cms.double(0.9), # dimensions of driftzone in cm z_min=cms.double(0.6), StripWidth=cms.vdouble(0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14, 0.14), diffCoeff=cms.vdouble(0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40, 0.40), gain=cms.vdouble(15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000, 15000)), padHit=cms.PSet( #diffCoeff = cms.double(0.26), # diffusion coefficient of driftzone
import FWCore.ParameterSet.Config as cms # Energy scale correction for Island Endcap SuperClusters correctedIslandEndcapSuperClusters = cms.EDProducer( "EgammaSCCorrectionMaker", corectedSuperClusterCollection=cms.string(''), sigmaElectronicNoise=cms.double(0.15), superClusterAlgo=cms.string('Island'), etThresh=cms.double(0.0), rawSuperClusterProducer=cms.InputTag("islandSuperClusters", "islandEndcapSuperClusters"), applyEnergyCorrection=cms.bool(True), isl_fCorrPset=cms.PSet(brLinearLowThr=cms.double(0.0), fBremVec=cms.vdouble(0.0), brLinearHighThr=cms.double(0.0), fEtEtaVec=cms.vdouble(0.0)), VerbosityLevel=cms.string('ERROR'), recHitProducer=cms.InputTag("ecalRecHit", "EcalRecHitsEE")) from Configuration.Eras.Modifier_pA_2016_cff import pA_2016 from Configuration.Eras.Modifier_peripheralPbPb_cff import peripheralPbPb from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017 from Configuration.Eras.Modifier_ppRef_2017_cff import ppRef_2017 from RecoHI.HiEgammaAlgos.HiCorrectedIslandEndcapSuperClusters_cfi import correctedIslandEndcapSuperClusters as _hiCorrectedIslandEndcapSuperClusters for e in [pA_2016, peripheralPbPb, pp_on_XeXe_2017, ppRef_2017]: e.toReplaceWith(correctedIslandEndcapSuperClusters, _hiCorrectedIslandEndcapSuperClusters)
Verbosity=cms.untracked.int32(0), AddAntiParticle=cms.bool(False)) process.o1 = cms.OutputModule("PoolOutputModule", process.FEVTSIMEventContent, fileName=cms.untracked.string('sim2003.root')) process.Timing = cms.Service("Timing") process.p1 = cms.Path(process.generator * process.VtxSmeared * process.generatorSmeared * process.g4SimHits) process.outpath = cms.EndPath(process.o1) process.common_maximum_timex = cms.PSet( MaxTrackTime=cms.double(1000.0), MaxTimeNames=cms.vstring(), MaxTrackTimes=cms.vdouble(), MaxTrackTimeForward=cms.double(2000.0), # ns MaxZCentralCMS=cms.double(50.0), # m DeadRegions=cms.vstring(), CriticalEnergyForVacuum=cms.double(2.0), CriticalDensity=cms.double(1e-15)) process.g4SimHits.NonBeamEvent = True process.g4SimHits.UseMagneticField = False process.g4SimHits.Physics.type = 'SimG4Core/Physics/QGSP_FTFP_BERT_EML' process.g4SimHits.Physics.Region = 'HcalRegion' process.g4SimHits.Physics.DefaultCutValue = 1. process.g4SimHits.ECalSD.UseBirkLaw = True process.g4SimHits.ECalSD.BirkL3Parametrization = True process.g4SimHits.ECalSD.BirkC1 = 0.033 process.g4SimHits.ECalSD.BirkC2 = 0.0
def customize(self,process): self.parse() isFwlite = False hasOutput = False hasTFile = False if hasattr(process,"fwliteInput"): isFwlite = True if not isFwlite: hasOutput = hasattr(process,"out") hasTFile = hasattr(process,"TFileService") if hasOutput and hasTFile: tfile = self.outputFile.replace(".root","_histos.root") else: tfile = self.outputFile if self.dryRun: import sys if self.dataset and self.dataset != "": name,xsec,totEvents,files,maxEvents = self.dataset if self.getMaxJobs: print "maxJobs:%d" % ( min(len(files),self.nJobs) ) if len(files) != 0: if isFwlite: print "hadd:%s" % self.outputFile else: if hasOutput: print "edm:%s" % self.outputFile if hasTFile or self.tfileOut: print "hadd:%s" % tfile ## sys.exit(0) else: sys.exit(1) files = self.inputFiles if self.dataset and self.dataset != "": dsetname,xsec,totEvents,files,maxEvents = self.dataset self.maxEvents = int(maxEvents) putarget = None samplepu = None if self.puTarget != "": putarget = map(float, self.puTarget.split(",")) processId = self.getProcessId(dsetname) self.processIndex = self.options.processIndex self.processId = processId isdata = self.processType == "data" if isdata or self.targetLumi > 0. or putarget: ## look for analyzers which have lumiWeight as attribute for name,obj in process.__dict__.iteritems(): if hasattr(obj,"lumiWeight"): if isdata: obj.lumiWeight = 1. else: wei = xsec["xs"]/float(totEvents)*self.targetLumi wei *= xsec.get("br",1.) wei *= xsec.get("kf",1.) obj.lumiWeight = wei if hasattr(obj,"intLumi"): if isdata: obj.intLumi= 0 # should not be used in final fits. # setting to 0 will cause error if someone tries to use #it for normalization downsteram else: obj.intLumi=self.targetLumi if putarget and not isdata: puObj = None if hasattr(obj,"puReWeight"): puObj = obj elif hasattr(obj,"globalVariables") and hasattr(obj.globalVariables,"puReWeight"): puObj = obj.globalVariables if puObj: if not samplepu: matches = filter(lambda x: x in dsetname, self.pu_distribs.keys() ) print matches if len(matches) > 1: matches = filter(lambda x: x == dsetname, matches) if len(matches) != 1: raise Exception("Could not determine sample pu distribution for reweighting. Possible matches are [%s]. Selected [%s]\n dataset: %s" % ( ",".join(self.pu_distribs.keys()), ",".join(matches), dsetname ) ) samplepu = self.pu_distribs[matches[0]] puObj.puReWeight = True puObj.puBins = cms.vdouble( map(float, samplepu.probFunctionVariable) ) puObj.mcPu = samplepu.probValue ## puObj.mcPu = [0.00023481895458601418, 0.0007044568637580425, 0.0020664068003569246, 0.005353872164561123, 0.01009721504719861, 0.016155544075517777, 0.02385760578593904, 0.03289813553750059, 0.04172732822993472, 0.0496876907904006, 0.05544075517775795, 0.06079462734231907, 0.06027802564222984, 0.06499788662940872, 0.06401164702014747, 0.06443432113840229, 0.06196872211524914, 0.05692011459164984, 0.0529986380500634, 0.044991311698680314, 0.04283097731648899, 0.03613863711078758, 0.03116047527356408, 0.024327243695111068, 0.02115718780819988, 0.017940168130371484, 0.01425351054337106, 0.011153900342835674, 0.008641337528765322, 0.005870473864650355, 0.004696379091720284, 0.0033344291551214013, 0.0027238998731977646, 0.0021133705912741276, 0.0010332034001784623, 0.0011036490865542667, 0.0003757103273376227, 0.00035222843187902126, 0.00023481895458601418, 0.0003991922227962241, 0.00016437326821020992, 0.0001408913727516085, 4.6963790917202836e-05, 7.044568637580425e-05, 4.6963790917202836e-05, 2.3481895458601418e-05, 4.6963790917202836e-05,4.6963790917202836e-05,4.6963790917202836e-05,4.6963790917202836e-05,4.6963790917202836e-05,4.6963790917202836e-05] ## puObj.mcPu = [2.0983716635890548e-05, 0.0001259022998153433, 0.0009022998153432936, 0.002245257680040289, 0.00574953835823401, 0.009904314252140339, 0.016703038442168878, 0.02400537183145879, 0.031979184153097195, 0.04114906832298137, 0.047737955346651, 0.056068490851099544, 0.05936293436293436, 0.06339180795702534, 0.06712690951821386, 0.06563706563706563, 0.06263639415813328, 0.06123048514352862, 0.05585865368474064, 0.052522242739634045, 0.04746516703038442, 0.04247104247104247, 0.035462481114655026, 0.03017458452241061, 0.025474231995971125, 0.021277488668793018, 0.018108947456773543, 0.012821050864529126, 0.011226288400201444, 0.008519388954171562, 0.00612724525768004, 0.004238710760449891, 0.004196743327178109, 0.002371159979855632, 0.0017206647641430251, 0.0012170555648816517, 0.0006714789323484975, 0.0006085277824408259, 0.00039869061608192044, 0.00031475574953835825, 0.0002518045996306866, 6.295114990767164e-05, 0.00014688601645123384, 6.295114990767164e-05, 6.295114990767164e-05, 4.1967433271781096e-05, 2.0983716635890548e-05, 4.1967433271781096e-05, 4.1967433271781096e-05, 2.0983716635890548e-05, 2.0983716635890548e-05, 2.0983716635890548e-05] puObj.dataPu = cms.vdouble(putarget) puObj.useTruePu = cms.bool(True) for name,obj in process.__dict__.iteritems(): if hasattr(obj,"processId"): obj.processId = str(processId) for name,obj in process.__dict__.iteritems(): if hasattr(obj,"processIndex"): obj.processIndex = int(self.processIndex) if isdata and self.lumiMask != "": if isFwlite: sys.exit("Lumi mask not supported in FWlite",-1) import FWCore.PythonUtilities.LumiList as LumiList process.source.lumisToProcess = LumiList.LumiList(filename = self.lumiMask).getVLuminosityBlockRange() flist = [] for f in files: if len(f.split(":",1))>1: flist.append(str(f)) else: flist.append(str("%s%s" % (self.filePrepend,f))) if len(flist) > 0: ## fwlite if isFwlite: ## process.fwliteInput.fileNames.extend([ str("%s%s" % (self.filePrepend,f)) for f in files]) process.fwliteInput.fileNames = flist ## full framework else: ## process.source.fileNames.extend([ str("%s%s" % (self.filePrepend,f)) for f in files]) process.source.fileNames = flist ## fwlite if isFwlite: process.fwliteInput.maxEvents = self.maxEvents process.fwliteOutput.fileName = self.outputFile ## full framework else: process.maxEvents.input = self.maxEvents if hasOutput: process.out.fileName = self.outputFile if hasTFile: process.TFileService.fileName = tfile if self.tfileOut: if hasTFile: print "Could not run with both TFileService and custom tfileOut" sys.exit(-1) name,attr = self.tfileOut setattr( getattr( process, name ), attr, tfile ) if self.dumpPython != "": from gzip import open pyout = open("%s.gz" % self.dumpPython,"w+") pyout.write( process.dumpPython() ) pyout.close()
CaloSteppingAction = cms.PSet( EBSDNames = cms.vstring('EBRY'), EESDNames = cms.vstring('EFRY'), HCSDNames = cms.vstring('HBS','HES','HTS'), SlopeLightYield = cms.double(0.02), BirkC1EC = cms.double(0.03333), BirkSlopeEC = cms.double(0.253694), BirkCutEC = cms.double(0.1), BirkC1HC = cms.double(0.0052), BirkC2HC = cms.double(0.142), BirkC3HC = cms.double(1.75), HitCollNames = cms.vstring('EcalHitsEB1','EcalHitsEE1', 'HcalHits1'), EtaTable = cms.vdouble(0.000, 0.087, 0.174, 0.261, 0.348, 0.435, 0.522, 0.609, 0.696, 0.783, 0.870, 0.957, 1.044, 1.131, 1.218, 1.305, 1.392, 1.479, 1.566, 1.653, 1.740, 1.830, 1.930, 2.043, 2.172, 2.322, 2.500, 2.650, 2.868, 3.000), PhiBin = cms.vdouble(5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0,10.0, 10.0,10.0,10.0,10.0,10.0,10.0,10.0, 10.0), PhiOffset = cms.vdouble( 0.0, 0.0, 0.0,10.0), EtaMin = cms.vint32(1, 16, 29, 1), EtaMax = cms.vint32(16, 29, 41, 15), EtaHBHE = cms.int32(16), DepthHBHE = cms.vint32(2,4), Depth29Max = cms.int32(3), RMinHO = cms.double(3800), ZHO = cms.vdouble(0,1255,1418,3928,4100,6610),
import FWCore.ParameterSet.Config as cms candidatePointSeededTrackingRegionsFromBeamSpot = cms.EDProducer('CandidatePointSeededTrackingRegionsEDProducer', RegionPSet = cms.PSet( operationMode = cms.string('BeamSpotFixed'), seedingMode = cms.string('Candidate'), input = cms.InputTag(''), points = cms.PSet( eta = cms.vdouble(), phi = cms.vdouble() ), maxNRegions = cms.uint32(10), beamSpot = cms.InputTag('hltOnlineBeamSpot'), vertexCollection = cms.InputTag('hltPixelVertices'), maxNVertices = cms.uint32(1), ptMin = cms.double(0.9), originRadius = cms.double(0.2), zErrorBeamSpot = cms.double(24.2), deltaEta_Cand = cms.double(-1), deltaPhi_Cand = cms.double(-1), deltaEta_Point = cms.double(-1), deltaPhi_Point = cms.double(-1), precise = cms.bool(True), nSigmaZVertex = cms.double(3), zErrorVetex = cms.double(0.2), nSigmaZBeamSpot = cms.double(4), whereToUseMeasurementTracker = cms.string('ForSiStrips'), measurementTrackerName = cms.InputTag(''), searchOpt = cms.bool(False) ) )
'MDME(1584,1) = 0 ! 0.024000 c cbar', 'MDME(1585,1) = 0 ! 0.425000 g g g', 'MDME(1586,1) = 0 ! 0.020000 gamma g g', 'MDME(1587,1) = 0 ! 0.185000 Upsilon pi+ pi-', 'MDME(1588,1) = 0 ! 0.088000 Upsilon pi0 pi0', 'MDME(1589,1) = 0 ! 0.043000 chi_0b gamma', 'MDME(1590,1) = 0 ! 0.067000 chi_1b gamma', 'MDME(1591,1) = 0 ! 0.066000 chi_2b gamma', 'MSTP(142)=2 ! turns on the PYEVWT Pt re-weighting routine', 'PARJ(13)=0.750 ! probability that a c or b meson has S=1', 'PARJ(14)=0.162 ! probability that a meson with S=0 is produced with L=1, J=1', 'PARJ(15)=0.018 ! probability that a meson with S=1 is produced with L=1, J=0', 'PARJ(16)=0.054 ! probability that a meson with S=1 is produced with L=1, J=1', 'MSTP(145)=0 ! choice of polarization', 'MSTP(146)=0 ! choice of polarization frame ONLY when mstp(145)=1', 'MSTP(147)=0 ! particular helicity or density matrix component when mstp(145)=1', 'MSTP(148)=1 ! possibility to allow for final-state shower evolution, extreme case !', 'MSTP(149)=1 ! if mstp(148)=1, it determines the kinematics of the QQ~3S1(8)->QQ~3S1(8)+g branching' ), CSAParameters=cms.vstring( 'CSAMODE=6 ! cross-section reweighted quarkonia'), parameterSets=cms.vstring('pythiaUESettings', 'kinematics', 'pythiaNRQCD', 'CSAParameters'))) hiSignal.embeddingMode = True hiSignal.hadrons = cms.vint32(100553) hiSignal.hadronPtMax = cms.vdouble(12.) hiSignal.hadronPtMin = cms.vdouble(9.) ProductionFilterSequence = cms.Sequence(hiSignal)
from PhysicsTools.NanoAOD.common_cff import * rhoTable = cms.EDProducer("GlobalVariablesTableProducer", variables = cms.PSet( fixedGridRhoFastjetAll = ExtVar( cms.InputTag("fixedGridRhoFastjetAll"), "double", doc = "rho from all PF Candidates, used e.g. for JECs" ), fixedGridRhoFastjetCentralNeutral = ExtVar( cms.InputTag("fixedGridRhoFastjetCentralNeutral"), "double", doc = "rho from neutral PF Candidates with |eta| < 2.5, used e.g. for rho corrections of some lepton isolations" ), fixedGridRhoFastjetCentralCalo = ExtVar( cms.InputTag("fixedGridRhoFastjetCentralCalo"), "double", doc = "rho from calo towers with |eta| < 2.5, used e.g. egamma PFCluster isolation" ), fixedGridRhoFastjetCentral = ExtVar( cms.InputTag("fixedGridRhoFastjetCentral"), "double", doc = "rho from all PF Candidates for central region, used e.g. for JECs" ), fixedGridRhoFastjetCentralChargedPileUp = ExtVar( cms.InputTag("fixedGridRhoFastjetCentralChargedPileUp"), "double", doc = "rho from charged PF Candidates for central region, used e.g. for JECs" ), ) ) puTable = cms.EDProducer("NPUTablesProducer", src = cms.InputTag("slimmedAddPileupInfo"), pvsrc = cms.InputTag("offlineSlimmedPrimaryVertices"), zbins = cms.vdouble( [0.0,1.7,2.6,3.0,3.5,4.2,5.2,6.0,7.5,9.0,12.0] ), savePtHatMax = cms.bool(False), ) genTable = cms.EDProducer("SimpleGenEventFlatTableProducer", src = cms.InputTag("generator"), cut = cms.string(""), name= cms.string("Generator"), doc = cms.string("Generator information"), singleton = cms.bool(True), extension = cms.bool(False), variables = cms.PSet( x1 = Var( "?hasPDF?pdf().x.first:-1", float, doc="x1 fraction of proton momentum carried by the first parton",precision=14 ), x2 = Var( "?hasPDF?pdf().x.second:-1", float, doc="x2 fraction of proton momentum carried by the second parton",precision=14 ), xpdf1 = Var( "?hasPDF?pdf().xPDF.first:-1", float, doc="x*pdf(x) for the first parton", precision=14 ), xpdf2 = Var( "?hasPDF?pdf().xPDF.second:-1", float, doc="x*pdf(x) for the second parton", precision=14 ),
import FWCore.ParameterSet.Config as cms from TauAnalysis.Core.diTauCandidateHistManager_cfi import * from TauAnalysis.Core.caloMEtHistManager_cfi import * from TauAnalysis.Core.pfMEtHistManager_cfi import * diTauCandidateEventActivityHistManager = cms.PSet( pluginName=cms.string('diTauCandidateEventActivityHistManager'), pluginType=cms.string('DiCandidatePairEventActivityHistManager'), diTauCandidateSource=cms.InputTag('selectedMuTauPairsPzetaDiffCumulative'), dRveto=cms.double(0.5), etaGaps=cms.vdouble(0.5, 1.0, 1.5, 2.0), particlePtThresholds=cms.vdouble(0.5, 1.0, 1.5, 2.0), chargedParticlePtThresholds=cms.vdouble(0.5, 1.0, 1.5, 2.0), jetPtThresholds=cms.vdouble(10.0, 15.0, 20.0), pfCandidateSource=cms.InputTag('particleFlow'), patJetSource=cms.InputTag('patJets'), dqmDirectory_store=cms.string('DiTauCandidateEventActivityQuantities'), #requireGenMatch = cms.bool(True), requireGenMatch=cms.bool(False), #normalization = cms.string("diTauCandidates"), normalization=cms.string("events"))
thePixelColEfficiency_BPix1=cms.double(1), thePixelColEfficiency_BPix2=cms.double(1), thePixelColEfficiency_BPix3=cms.double(1), thePixelColEfficiency_FPix1=cms.double(0.999), thePixelColEfficiency_FPix2=cms.double(0.999), thePixelEfficiency_BPix1=cms.double(1), thePixelEfficiency_BPix2=cms.double(1), thePixelEfficiency_BPix3=cms.double(1), thePixelEfficiency_FPix1=cms.double(0.999), thePixelEfficiency_FPix2=cms.double(0.999), thePixelChipEfficiency_BPix1=cms.double(1), thePixelChipEfficiency_BPix2=cms.double(1), thePixelChipEfficiency_BPix3=cms.double(1), thePixelChipEfficiency_FPix1=cms.double(0.999), thePixelChipEfficiency_FPix2=cms.double(0.999), theLadderEfficiency_BPix1=cms.vdouble([1] * 20), theLadderEfficiency_BPix2=cms.vdouble([1] * 32), theLadderEfficiency_BPix3=cms.vdouble([1] * 44), theModuleEfficiency_BPix1=cms.vdouble([1] * 4), theModuleEfficiency_BPix2=cms.vdouble([1] * 4), theModuleEfficiency_BPix3=cms.vdouble([1] * 4), theInnerEfficiency_FPix1=cms.double(1), theInnerEfficiency_FPix2=cms.double(1), theOuterEfficiency_FPix1=cms.double(1), theOuterEfficiency_FPix2=cms.double(1), thePUEfficiency_BPix1=cms.vdouble(1, -0.00467063, -0.000466703), thePUEfficiency_BPix2=cms.vdouble(1, -0.00245103), thePUEfficiency_BPix3=cms.vdouble(1, -0.00132013), thePUEfficiency_FPix_Inner=cms.vdouble(1), thePUEfficiency_FPix_Outer=cms.vdouble(1), theInstLumiScaleFactor=cms.double(0.3273),
import FWCore.ParameterSet.Config as cms hltHcalPFClusterIsolationProducerRecoRecoEcalCandidate = cms.EDProducer('EgammaHLTHcalPFClusterIsolationProducer', recoEcalCandidateProducer = cms.InputTag('hltL1SeededRecoEcalCandidatePF'), pfClusterProducerHCAL = cms.InputTag('hltParticleFlowClusterHCAL'), useHF = cms.bool(False), pfClusterProducerHFEM = cms.InputTag(''), pfClusterProducerHFHAD = cms.InputTag(''), rhoProducer = cms.InputTag('fixedGridRhoFastjetAllCalo'), doRhoCorrection = cms.bool(False), rhoMax = cms.double(99999999), rhoScale = cms.double(1), drMax = cms.double(0.3), drVetoBarrel = cms.double(0), drVetoEndcap = cms.double(0), etaStripBarrel = cms.double(0), etaStripEndcap = cms.double(0), energyBarrel = cms.double(0), energyEndcap = cms.double(0), useEt = cms.bool(True), effectiveAreas = cms.vdouble( 0.2, 0.25 ), absEtaLowEdges = cms.vdouble( 0, 1.479 ), mightGet = cms.optional.untracked.vstring )
max_lostHitFraction = 1.0, d0_par1 = ( 0.8, 4.0 ), dz_par1 = ( 0.8, 4.0 ), d0_par2 = ( 0.8, 4.0 ), dz_par2 = ( 0.8, 4.0 ) ) ) #end of vpset ) #end of clone import RecoTracker.FinalTrackSelectors.trackListMerger_cfi mixedTripletStep = RecoTracker.FinalTrackSelectors.trackListMerger_cfi.trackListMerger.clone( TrackProducers = cms.VInputTag(cms.InputTag('mixedTripletStepTracks'), cms.InputTag('mixedTripletStepTracks')), hasSelector=cms.vint32(1,1), shareFrac=cms.double(0.11), indivShareFrac=cms.vdouble(0.11,0.11), selectedTrackQuals = cms.VInputTag(cms.InputTag("mixedTripletStepSelector","mixedTripletStepVtx"), cms.InputTag("mixedTripletStepSelector","mixedTripletStepTrk")), setsToMerge = cms.VPSet( cms.PSet( tLists=cms.vint32(0,1), pQual=cms.bool(True) )), writeOnlyTrkQuals=cms.bool(True) ) MixedTripletStep = cms.Sequence(mixedTripletStepClusters* mixedTripletStepSeedsA* mixedTripletStepSeedsB* mixedTripletStepSeeds* mixedTripletStepTrackCandidates* mixedTripletStepTracks* mixedTripletStepSelector* mixedTripletStep)
mass_low=cms.double(60.0), # GeV mass_high=cms.double(120.0), # GeV mass_bin_width=cms.double(2.0), # GeV # datasets to run on # datasets = cms.VPSet(dy_madgraph, single_el), datasets=cms.VPSet(dy_full_80X, single_el_2016), # datasets = cms.VPSet(dy_full), #datasets = cms.VPSet(dy_test, double_el_test), ## bins for the observables ## supported pt, eta, phi, and # vertices ## note: for eta and phi, no negative bins means use |eta| and |phi|, respectively # pt_bins = cms.vdouble(10, 25, 40, 50, 200), # pt_bins = cms.vdouble(5, 10, 20), pt_bins=cms.vdouble(30, 50, 70, 100, 150, 200), eta_bins=cms.vdouble(0, 0.8, 1.4442, 1.566, 2.0, 2.5), # eta_bins = cms.vdouble(0, 0.8, 1.5, 2.5), # eta_bins = cms.vdouble(-2.5, -2.0, -1.566, -1.4442, -0.8, 0, 0.8, 1.4442, 1.566, 2.0, 2.5), # phi_bins = cms.vdouble(0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.15), phi_bins=cms.vdouble(), # nvtx_bins = cms.vdouble(0, 5, 10, 15, 20, 25, 30, 35, 40), nvtx_bins=cms.vdouble(), activity_bins=cms.vdouble(), ## W/Z measurement bins #pt_bins = cms.vdouble(25, 40, 55, 200), #eta_bins = cms.vdouble(-2.5, -2, -1.566, -1.442, -1, -0.5, 0, 0.5, 1, 1.4442, 1.566, 2, 2.5), ## selection (from Measurements.h/cc) # numerator = cms.string("EGammaMediumSTOPIso"),
#BTV hltTOPmonitoring.histoPSet.DRPSet = cms.PSet( nbins=cms.uint32(60), xmin=cms.double(0.0), xmax=cms.double(6.0), ) #Suvankar hltTOPmonitoring.applyleptonPVcuts = cms.bool(False) hltTOPmonitoring.leptonPVcuts = cms.PSet( dxy=cms.double(9999.), dz=cms.double(9999.), ) #MET and HT binning hltTOPmonitoring.histoPSet.metBinning = cms.vdouble(0, 20, 40, 60, 80, 100, 125, 150, 175, 200) hltTOPmonitoring.histoPSet.HTBinning = cms.vdouble(0, 20, 40, 60, 80, 100, 125, 150, 175, 200, 300, 400, 500, 700) #Eta binning hltTOPmonitoring.histoPSet.eleEtaBinning = cms.vdouble(-2.4, -2.1, -1.5, -0.9, -0.3, 0., 0.3, 0.9, 1.5, 2.1, 2.4) hltTOPmonitoring.histoPSet.jetEtaBinning = cms.vdouble(-2.4, -2.1, -1.5, -0.9, -0.3, 0., 0.3, 0.9, 1.5, 2.1, 2.4) hltTOPmonitoring.histoPSet.muEtaBinning = cms.vdouble(-2.4, -2.1, -1.5, -0.9, -0.3, 0., 0.3, 0.9, 1.5, 2.1, 2.4) #pt binning hltTOPmonitoring.histoPSet.elePtBinning = cms.vdouble(0, 5, 10, 20, 30, 40, 50,
import FWCore.ParameterSet.Config as cms #---------------------------------------------------------------------------------------------------- # Global variables #---------------------------------------------------------------------------------------------------- # # Info: These are variables that are required by several modules. # #---------------------------------------------------------------------------------------------------- # Specify the boundaries of the eta regions in which to apply local PU subtraction gLocalRhoEtaDivisions = cms.vdouble(-3.0, -1.3, 0.0, 1.3, 3.0) # Run on Asymmetry filtered jets #gPrePUSJets = "L1TowerJetFilter2D" # Run on Centrality filtered jets gPrePUSJets = "L1TowerJetCentralityFilter" #==================================================================================================== L1CaloTriggerSetupSource = cms.ESSource( "EmptyESSource", recordName=cms.string('L1CaloTriggerSetupRcd'), firstValid=cms.vuint32(1), iovIsRunNotTime=cms.bool(True)) L1CaloTriggerSetup = cms.ESProducer( "L1CaloTriggerSetupProducer", InputXMLFile=cms.FileInPath( 'SLHCUpgradeSimulations/L1CaloTrigger/data/setup.xml'))