def customiseFor19181_pixel_phase0(process): for producer in producers_by_type(process, "SiPixelClusterProducer"): producer.VCaltoElectronGain_L1 = cms.int32(65) producer.VCaltoElectronOffset_L1 = cms.int32(-414) producer.ClusterThreshold = cms.int32(4000) producer.ClusterThreshold_L1 = cms.int32(4000) return process
def electronTriggerMatchPT(process,triggerProcess): process.triggeredPatElectronsL = cms.EDProducer("ElectronTriggerMatcher", src = cms.InputTag("cleanPatElectrons"), trigEvent = cms.InputTag("hltTriggerSummaryAOD"), filters = cms.VInputTag( cms.InputTag('hltEle17CaloIdLCaloIsoVLPixelMatchFilterDoubleEG125','',triggerProcess), ), pdgId = cms.int32(0) ) process.triggeredPatElectrons = cms.EDProducer("ElectronTriggerMatcher", src = cms.InputTag("triggeredPatElectronsL"), trigEvent = cms.InputTag("hltTriggerSummaryAOD"), filters = cms.VInputTag( cms.InputTag('hltOverlapFilterIsoEle15IsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle15TightIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle18MediumIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle18TightIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle18IsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle20MediumIsoPFTau20','',triggerProcess) ), pdgId = cms.int32(11) ) process.analysisSequence=cms.Sequence(process.analysisSequence*process.triggeredPatElectronsL*process.triggeredPatElectrons)
def customizeTSGForOIWithPropagator(process): process.hltIterL3OISeedsFromL2Muons = cms.EDProducer( "TSGForOI", hitsToTry = cms.int32( 3 ), adjustErrorsDynamicallyForHitless = cms.bool( True ), SF4 = cms.double( 7.0 ), SF5 = cms.double( 10.0 ), SF2 = cms.double( 4.0 ), SF3 = cms.double( 5.0 ), SF1 = cms.double( 3.0 ), minEtaForTEC = cms.double( 0.7 ), fixedErrorRescaleFactorForHits = cms.double( 3.0 ), maxSeeds = cms.uint32( 5 ), maxEtaForTOB = cms.double( 1.8 ), pT3 = cms.double( 70.0 ), pT2 = cms.double( 30.0 ), pT1 = cms.double( 13.0 ), layersToTry = cms.int32( 2 ), fixedErrorRescaleFactorForHitless = cms.double( 10.0 ), MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), adjustErrorsDynamicallyForHits = cms.bool( True ), src = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), tsosDiff = cms.double( 0.03 ), eta1 = cms.double( 1.0 ), eta2 = cms.double( 1.4 ), UseHitLessSeeds = cms.bool( True ), UseStereoLayersInTEC = cms.bool( False ), estimator = cms.string( "hltESPChi2MeasurementEstimator100" ), debug = cms.untracked.bool( False ), propagatorAlongName = cms.string( "PropagatorWithMaterial" ), propagatorOppositeName = cms.string( "PropagatorWithMaterial" ), propagatorHitlessName = cms.string( "PropagatorWithMaterial" ), propagatorHitBasedName = cms.string( "PropagatorWithMaterial" ), )
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 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 eleMomentumRegression(process, datasetpath, datatype): # generate hash from datasetpath and form unique but constant seed for each sample # !!! WARNING: seed is still dependent on job splitting !!! to_hash = datasetpath hash_input = to_hash.split("=")[1].strip() generate_hash = hashlib.md5(hash_input) seed = abs(int(str(int(generate_hash.hexdigest(),16))[0:9])) # crab expects uint32 -> only up to 9 digits of hash can be safely used process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService", calibratedElectrons = cms.PSet( initialSeed = cms.untracked.uint32(seed), engineName = cms.untracked.string("TRandom3") ), ) process.load("EgammaAnalysis.ElectronTools.calibratedElectrons_cfi") if datatype == "Data" or "embedded" in datatype: process.calibratedElectrons.isMC = cms.bool(False) process.calibratedElectrons.inputDataset = cms.string("22Jan2013ReReco") else: process.calibratedElectrons.isMC = cms.bool(True) process.calibratedElectrons.inputDataset = cms.string("Summer12_LegacyPaper") process.calibratedElectrons.updateEnergyError = cms.bool(True) process.calibratedElectrons.correctionsType = cms.int32(2) process.calibratedElectrons.combinationType = cms.int32(3) process.calibratedElectrons.applyLinearityCorrection = cms.bool(True) process.load('EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi') process.eleRegressionEnergy.inputElectronsTag = cms.InputTag('gsfElectrons') process.eleRegressionEnergy.inputCollectionType = cms.uint32(0) process.eleRegressionEnergy.useRecHitCollections = cms.bool(True) process.eleRegressionEnergy.produceValueMaps = cms.bool(True) process.eleRegressionEnergy.regressionInputFile = cms.string("EgammaAnalysis/ElectronTools/data/eleEnergyRegWeights_WithSubClusters_VApr15.root") process.eleRegressionEnergy.energyRegressionType = cms.uint32(2)
def customise(process): # From python/simEmtfDigis_cfi.py if hasattr(process, 'simEmtfDigis'): process.simEmtfDigis.spPCParams16.ZoneBoundaries = [0,36,54,96,127] process.simEmtfDigis.spPCParams16.UseNewZones = True process.simEmtfDigis.RPCEnable = True process.simEmtfDigis.GEMEnable = True process.simEmtfDigis.IRPCEnable = True process.simEmtfDigis.ME0Enable = True process.simEmtfDigis.TTEnable = False process.simEmtfDigis.ME0Input = cms.InputTag('fakeSimMuonME0PadDigis') process.simEmtfDigis.Era = cms.string('Phase2C2') process.simEmtfDigis.spPAParams16.PtLUTVersion = cms.int32(7) # From python/fakeEmtfParams_cff.py if hasattr(process, 'emtfParams'): process.emtfParams.PtAssignVersion = cms.int32(7) if hasattr(process, 'emtfForestsDB'): process.emtfForestsDB = cms.ESSource( "EmptyESSource", recordName = cms.string('L1TMuonEndCapForestRcd'), iovIsRunNotTime = cms.bool(True), firstValid = cms.vuint32(1) ) process.emtfForests = cms.ESProducer( "L1TMuonEndCapForestESProducer", PtAssignVersion = cms.int32(7), bdtXMLDir = cms.string("2017_v7") ) return process
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 _modifyPixelDigitizerForPhase1Pixel( digitizer ) : """ Function that modifies the pixel digitiser for the Phase 1 pixel detector. First argument is the pixelDigitizer object. """ #use default switches, new analog respnse, d.k. 2/16 #digitizer.MissCalibrate = False #digitizer.LorentzAngle_DB = False #digitizer.killModules = False #digitizer.useDB = False #digitizer.DeadModules_DB = False digitizer.NumPixelBarrel = cms.int32(4) digitizer.NumPixelEndcap = cms.int32(3) digitizer.ThresholdInElectrons_FPix = cms.double(2000.0) digitizer.ThresholdInElectrons_BPix = cms.double(2000.0) digitizer.ThresholdInElectrons_BPix_L1 = cms.double(2000.0) digitizer.FPix_SignalResponse_p0 = cms.double(0.00171) digitizer.FPix_SignalResponse_p1 = cms.double(0.711) digitizer.FPix_SignalResponse_p2 = cms.double(203.) digitizer.FPix_SignalResponse_p3 = cms.double(148.) digitizer.BPix_SignalResponse_p0 = cms.double(0.00171) digitizer.BPix_SignalResponse_p1 = cms.double(0.711) digitizer.BPix_SignalResponse_p2 = cms.double(203.) digitizer.BPix_SignalResponse_p3 = cms.double(148.)
def customise_Validation(process,pileup): process.validation_step.remove(process.PixelTrackingRecHitsValid) process.validation_step.remove(process.stripRecHitsValid) process.validation_step.remove(process.trackerHitsValid) process.validation_step.remove(process.StripTrackingRecHitsValid) # We don't run the HLT process.validation_step.remove(process.HLTSusyExoVal) process.validation_step.remove(process.hltHiggsValidator) process.validation_step.remove(process.relvalMuonBits) if pileup>30: process.trackValidator.label=cms.VInputTag(cms.InputTag("cutsRecoTracksHp")) process.tracksValidationSelectors = cms.Sequence(process.cutsRecoTracksHp) process.globalValidation.remove(process.recoMuonValidation) process.validation.remove(process.recoMuonValidation) process.validation_preprod.remove(process.recoMuonValidation) process.validation_step.remove(process.recoMuonValidation) process.validation.remove(process.globalrechitsanalyze) process.validation_prod.remove(process.globalrechitsanalyze) process.validation_step.remove(process.globalrechitsanalyze) process.validation.remove(process.stripRecHitsValid) process.validation_step.remove(process.stripRecHitsValid) process.validation_step.remove(process.StripTrackingRecHitsValid) process.globalValidation.remove(process.vertexValidation) process.validation.remove(process.vertexValidation) process.validation_step.remove(process.vertexValidation) process.mix.input.nbPileupEvents.averageNumber = cms.double(0.0) process.mix.minBunch = cms.int32(0) process.mix.maxBunch = cms.int32(0) if hasattr(process,'simHitTPAssocProducer'): process.simHitTPAssocProducer.simHitSrc=cms.VInputTag(cms.InputTag("g4SimHits","TrackerHitsPixelBarrelLowTof"), cms.InputTag("g4SimHits","TrackerHitsPixelEndcapLowTof")) return process
def addCategory(pset,label,cutbased=None,subcats=0,variables=[],histograms=[],mvas=None,classname=None,binnedOnly=None, dumpPdfWeights=None,nPdfWeights=None,nAlphaSWeights=None,nScaleWeights=None,splitPdfByStage0Cat=None): if subcats >= 0: catDef = cms.PSet(label=cms.string(label), subcats=cms.int32(subcats), variables=cms.VPSet(), histograms=cms.VPSet(), ) if classname: catDef.className=cms.string(classname) if binnedOnly: catDef.binnedOnly=cms.bool(binnedOnly) if dumpPdfWeights: catDef.dumpPdfWeights=cms.bool(dumpPdfWeights) if nPdfWeights: catDef.nPdfWeights=cms.int32(nPdfWeights) if nAlphaSWeights: catDef.nAlphaSWeights=cms.int32(nAlphaSWeights) if nScaleWeights: catDef.nScaleWeights=cms.int32(nScaleWeights) if splitPdfByStage0Cat is not None: catDef.splitPdfByStage0Cat=cms.bool(splitPdfByStage0Cat) addVariables( catDef.variables, variables ) addHistograms( catDef.histograms, histograms ) if mvas: catDef.mvas = cms.VPSet() addMVAs( catDef.mvas, mvas ) pset.categories.append(catDef) if cutbased: cb = cms.PSet( cut=cms.string(cutbased) ) if( label != "" or classname): cb.name = cms.untracked.string(label) pset.classifierCfg.categories.append(cb)
def customise_Digi(process): process.mix.digitizers.pixel.MissCalibrate = False process.mix.digitizers.pixel.LorentzAngle_DB = False process.mix.digitizers.pixel.killModules = False process.mix.digitizers.pixel.useDB = False process.mix.digitizers.pixel.DeadModules_DB = False process.mix.digitizers.pixel.NumPixelBarrel = cms.int32(10) process.mix.digitizers.pixel.NumPixelEndcap = cms.int32(7) process.mix.digitizers.pixel.ThresholdInElectrons_FPix = cms.double(2000.0) process.mix.digitizers.pixel.ThresholdInElectrons_BPix = cms.double(2000.0) process.mix.digitizers.pixel.ThresholdInElectrons_BPix_L1 = cms.double(2000.0) process.mix.digitizers.pixel.thePixelColEfficiency_BPix4 = cms.double(0.999) process.mix.digitizers.pixel.thePixelEfficiency_BPix4 = cms.double(0.999) process.mix.digitizers.pixel.thePixelChipEfficiency_BPix4 = cms.double(0.999) process.mix.digitizers.pixel.thePixelColEfficiency_FPix3 = cms.double(0.999) process.mix.digitizers.pixel.thePixelEfficiency_FPix3 = cms.double(0.999) process.mix.digitizers.pixel.thePixelChipEfficiency_FPix3 = cms.double(0.999) process.mix.digitizers.pixel.AddPixelInefficiencyFromPython = cms.bool(False) process.mix.digitizers.strip.ROUList = cms.vstring("g4SimHitsTrackerHitsPixelBarrelLowTof", 'g4SimHitsTrackerHitsPixelEndcapLowTof') process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIBLowTof")) process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIBHighTof")) process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTOBLowTof")) process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTOBHighTof")) process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTECLowTof")) process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTECHighTof")) process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIDLowTof")) process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIDHighTof")) return process
def electronTriggerMatchPT(process,triggerProcess): process.triggeredPatElectronsL = cms.EDProducer("ElectronTriggerMatcher", src = cms.InputTag("cleanPatElectrons"), trigEvent = cms.InputTag("hltTriggerSummaryAOD"), filters = cms.VInputTag( cms.InputTag('hltEle17CaloIdLCaloIsoVLPixelMatchFilterDoubleEG125','',triggerProcess), ), pdgId = cms.int32(0) ) process.triggeredPatElectrons = cms.EDProducer("ElectronTriggerMatcher", src = cms.InputTag("triggeredPatElectronsL"), trigEvent = cms.InputTag("hltTriggerSummaryAOD"), filters = cms.VInputTag( cms.InputTag('hltOverlapFilterIsoEle15IsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle15TightIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle18MediumIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle18TightIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle18IsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle20MediumIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle20LooseIsoPFTau20','',triggerProcess), cms.InputTag('hltOverlapFilterIsoEle20WP90LooseIsoPFTau20','',triggerProcess), cms.InputTag('hltEle20CaloIdVTCaloIsoTTrkIdTTrkIsoTTrackIsoFilterL1IsoEG18OrEG20','',triggerProcess), cms.InputTag('hltEle22WP90RhoTrackIsoFilter','',triggerProcess), cms.InputTag('hltEle27WP80TrackIsoFilter','',triggerProcess), cms.InputTag('hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoFilter','',triggerProcess), cms.InputTag('hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoDoubleFilter','',triggerProcess), cms.InputTag('hltEle17CaloIdVTCaloIsoVTTrkIdTTrkIsoVTEle8TrackIsoFilter','',triggerProcess), cms.InputTag('hltEle20CaloIdVTCaloIsoVTTrkIdTTrkIsoVTSC4TrackIsoFilter','',triggerProcess) ), pdgId = cms.int32(11) ) process.analysisSequence=cms.Sequence(process.analysisSequence*process.triggeredPatElectronsL*process.triggeredPatElectrons)
def makeCategoryParams(llWPs=[], diLeptonTriggerMatch=False, addPassAll=False): categs = dict() ## take dilepton working points from input for l1 in ("El", "Mu"): for l2 in ("El", "Mu"): flav = "".join((l1,l2)) base = cms.PSet( NElectrons = cms.uint32(sum( 1 for l in (l1,l2) if l == "El" )) , NMuons = cms.uint32(sum( 1 for l in (l1,l2) if l == "Mu" )) , Category = cms.string("is{0}".format(flav)) , HLT = cms.vstring(dileptonTriggers[flav]) if diLeptonTriggerMatch else cms.vstring() , Cuts = cms.VPSet( cms.PSet(Mll = cms.string("p4.M > 20")) , cms.PSet(ZVeto = cms.string("( p4.M < 76 ) || ( p4.M > 116 )")) ) , WPs=cms.vstring(llWPs) ) categs["{0}OS".format(flav)] = base.clone(Charge=cms.int32( 0), Category=cms.string("is{0} && isOS".format(flav))) categs["{0}Plus".format(flav)] = base.clone(Charge=cms.int32( 1)) categs["{0}Minus".format(flav)] = base.clone(Charge=cms.int32(-1)) if addPassAll: categs["all"] = cms.PSet( NElectrons = cms.uint32(0) , NMuons = cms.uint32(0) , Category = cms.string("") , HLT = cms.vstring() , Cuts = cms.VPSet() , WPs = cms.vstring() , Charge = cms.int32(0) ) return cms.PSet(**categs)
def addMuMuSVFit(self, moduleName): dicand = cms.EDProducer("PATMuMuSVFitter") dicand.src = cms.InputTag(self.input) dicand.srcPrimaryVertex = cms.InputTag("offlinePrimaryVerticesWithBS") dicand.srcBeamSpot = cms.InputTag("offlineBeamSpot") dicand.svFit = cms.PSet( psKine=cms.PSet( likelihoodFunctions=cms.VPSet(svFitLikelihoodMuMuKinematicsPhaseSpace), estUncertainties=cms.PSet(numSamplings=cms.int32(-1)), ), psKine_MEt=cms.PSet( likelihoodFunctions=cms.VPSet(svFitLikelihoodMuMuKinematicsPhaseSpace, svFitLikelihoodMuMuMEt), estUncertainties=cms.PSet(numSamplings=cms.int32(-1)), ), psKine_MEt_ptBalance=cms.PSet( likelihoodFunctions=cms.VPSet( svFitLikelihoodMuMuKinematicsPhaseSpace, svFitLikelihoodMuMuMEt, svFitLikelihoodMuMuPtBalance ), estUncertainties=cms.PSet(numSamplings=cms.int32(-1)), ), ) pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid") setattr(pyModule, moduleName, dicand) self.sequence *= dicand self.input = moduleName
def _modifyPixelDigitizerForPhase1Pixel( digitizer ) : """ Function that modifies the pixel digitiser for the Phase 1 pixel detector. First argument is the pixelDigitizer object. """ #use default switches, new analog respnse, d.k. 2/16 #digitizer.MissCalibrate = False #digitizer.LorentzAngle_DB = False #digitizer.killModules = False #digitizer.useDB = False #digitizer.DeadModules_DB = False digitizer.NumPixelBarrel = cms.int32(4) digitizer.NumPixelEndcap = cms.int32(3) digitizer.ThresholdInElectrons_FPix = cms.double(2000.0) digitizer.ThresholdInElectrons_BPix = cms.double(2000.0) digitizer.ThresholdInElectrons_BPix_L1 = cms.double(2000.0) digitizer.FPix_SignalResponse_p0 = cms.double(0.00171) digitizer.FPix_SignalResponse_p1 = cms.double(0.711) digitizer.FPix_SignalResponse_p2 = cms.double(203.) digitizer.FPix_SignalResponse_p3 = cms.double(148.) digitizer.BPix_SignalResponse_p0 = cms.double(0.00171) digitizer.BPix_SignalResponse_p1 = cms.double(0.711) digitizer.BPix_SignalResponse_p2 = cms.double(203.) digitizer.BPix_SignalResponse_p3 = cms.double(148.) # gains and offsets are ints in the Clusterizer, so round to the same value digitizer.ElectronsPerVcal = cms.double(47) # L2-4: 47 +- 4.7 digitizer.ElectronsPerVcal_L1 = cms.double(50) # L1: 49.6 +- 2.6 digitizer.ElectronsPerVcal_Offset = cms.double(-60) # L2-4: -60 +- 130 digitizer.ElectronsPerVcal_L1_Offset = cms.double(-670) # L1: -670 +- 220
def defineExtraHlt(process): process.hltHcalSimpleRecHitFilterCoincidence2 = process.hltHcalSimpleRecHitFilterCoincidence.clone( minNHitsNeg = cms.int32(2), minNHitsPos = cms.int32(2), doCoincidence= cms.bool(True) ) process.HLT_HIActivityHF_Coincidence3_2Hit = process.HLT_HIActivityHF_Coincidence3.expandAndClone(); process.HLT_HIActivityHF_Coincidence3_2Hit.replace(process.hltHcalSimpleRecHitFilterCoincidence,process.hltHcalSimpleRecHitFilterCoincidence2)
def disableOOTPU(process): process.mix.maxBunch = cms.int32(0) process.mix.minBunch = cms.int32(0) # set the bunch spacing # bunch spacing matters for calorimeter calibration # by convention bunchspace is set to 450 in case of no oot pu process.mix.bunchspace = 450 return process
def customise(process): process.CFWriter = cms.EDProducer("CFWriter", maxBunch = cms.int32(3), minBunch = cms.int32(-5), mixObjects = cms.PSet( mixCH = cms.PSet( ), mixTracks = cms.PSet( ), mixVertices = cms.PSet( ), mixSH = cms.PSet( ), mixHepMC = cms.PSet( mixHepMCProducts ) ) ) process.pdigi = cms.Sequence(cms.SequencePlaceholder("randomEngineStateProducer")*cms.SequencePlaceholder("mix")*process.doAllDigi*process.trackingParticles*process.addPileupInfo*process.CFWriter) process.RECOSIMoutput.outputCommands.append("keep *_CFWriter_*_*") REDIGIInputEventSkimming= cms.PSet( inputCommands=cms.untracked.vstring('drop *') ) GeneratorInterfaceRAWNoGenParticles = process.GeneratorInterfaceRAW.outputCommands for item in GeneratorInterfaceRAWNoGenParticles: if 'genParticles' in item: GeneratorInterfaceRAWNoGenParticles.remove(item) REDIGIInputEventSkimming.inputCommands.extend(process.SimG4CoreRAW.outputCommands) REDIGIInputEventSkimming.inputCommands.extend(GeneratorInterfaceRAWNoGenParticles) REDIGIInputEventSkimming.inputCommands.extend(process.IOMCRAW.outputCommands) process.source.inputCommands = REDIGIInputEventSkimming.inputCommands process.source.dropDescendantsOfDroppedBranches=cms.untracked.bool(False) process.RandomNumberGeneratorService.restoreStateLabel = cms.untracked.string('randomEngineStateProducer') # Remove the old RNGState product on output RNGStateCleaning= cms.PSet( outputCommands=cms.untracked.vstring('drop RandomEngineStates_*_*_*', 'keep RandomEngineStates_*_*_'+process.name_()) ) for item in process.outputModules_().values(): item.outputCommands.extend(RNGStateCleaning.outputCommands) # REDO the GenJets etc. in case labels have been changed process.load('Configuration/StandardSequences/Generator_cff') process.fixGenInfo = cms.Path(process.GeneInfo * process.genJetMET) process.schedule.append(process.fixGenInfo) return(process)
def psetGsfEleEcalDrivenCut(wpEB, wpEE): return cms.PSet( cutName = cms.string('GsfEleEcalDrivenCut'), ecalDrivenEB = cms.int32( wpEB.ecalDrivenCut ), ecalDrivenEE = cms.int32( wpEE.ecalDrivenCut ), barrelCutOff = cms.double(ebCutOff), needsAdditionalProducts = cms.bool(False), isIgnored = cms.bool(False) )
def prepareGenMixing(process): # prepare digitizers and mixObjects for Gen-mixing process = prepareDigiRecoMixing(process) # for reasons of simplicity track mixing is not switched off, # although it has no effect in case of Gen-mixing # OOT PU not supported for Gen-mixing: disable it process.mix.maxBunch = cms.int32(0) process.mix.minBunch = cms.int32(0) # set the bunch spacing # bunch spacing matters for calorimeter calibration # setting the bunch spacing here, will have actually no effect, # but leads to consistency with the bunch spacing as hard coded in # FastSimulation/PileUpProducer/plugins/PileUpProducer.cc # where it is propagated to the pileUpInfo, from which calorimeter calibration reads the bunch spacing process.mix.bunchspace = 450 # define the PileUpProducer module process.famosPileUp = cms.EDProducer( "PileUpProducer", PileUpSimulator = cms.PSet(), VertexGenerator = cms.PSet() ) # get the pu vertex distribution process.famosPileUp.VertexGenerator = get_VertexGeneratorPSet_PileUpProducer(process) # get pu distribution from MixingModule process.famosPileUp.PileUpSimulator = get_PileUpSimulatorPSet_PileUpProducer(process.mix.input) # MixingModule only used for digitization, no need for input del process.mix.input # Insert the PileUpProducer in the simulation sequence pos = process.simulationSequence.index(process.famosSimHits) process.simulationSequence.insert(pos,process.famosPileUp) # No track mixing when Gen-mixing del process.mix.digitizers.tracker del process.mix.mixObjects.mixRecoTracks del process.generalTracks process.generalTracks = process.generalTracksBeforeMixing.clone() process.iterTracking.replace(process.generalTracksBeforeMixing,process.generalTracks) del process.generalTracksBeforeMixing # Use generalTracks where DIGI-RECO mixing requires preMixTracks process.generalConversionTrackProducer.TrackProducer = cms.string('generalTracks') process.trackerDrivenElectronSeeds.TkColList = cms.VInputTag(cms.InputTag("generalTracks")) # PileUp info must be read from PileUpProducer, rather than from MixingModule process.addPileupInfo.PileupMixingLabel = cms.InputTag("famosPileUp") return process
def customiseFor8679(process): if hasattr(process,'hltBSoftMuonMu5L3') : delattr(process.hltBSoftMuonMu5L3,'min3DHit') setattr(process.hltBSoftMuonMu5L3,'minLayer', cms.int32(0)) setattr(process.hltBSoftMuonMu5L3,'min3DLayer', cms.int32(0)) setattr(process.hltBSoftMuonMu5L3,'minPixelHit', cms.int32(0)) setattr(process.hltBSoftMuonMu5L3,'usePV', cms.bool(False)) setattr(process.hltBSoftMuonMu5L3,'vertexTag', cms.InputTag('')) return process
def customiseFor24329(process): for producer in producers_by_type(process, "SiPixelClusterProducer"): producer.ElectronPerADCGain = cms.double(135.) producer.Phase2Calibration = cms.bool(False) producer.Phase2ReadoutMode = cms.int32(-1) producer.Phase2DigiBaseline = cms.double(1200.) producer.Phase2KinkADC = cms.int32(8) return process
def customiseFor8679(process): if hasattr(process, "hltBSoftMuonMu5L3"): delattr(process.hltBSoftMuonMu5L3, "min3DHit") setattr(process.hltBSoftMuonMu5L3, "minLayer", cms.int32(0)) setattr(process.hltBSoftMuonMu5L3, "min3DLayer", cms.int32(0)) setattr(process.hltBSoftMuonMu5L3, "minPixelHit", cms.int32(0)) setattr(process.hltBSoftMuonMu5L3, "usePV", cms.bool(False)) setattr(process.hltBSoftMuonMu5L3, "vertexTag", cms.InputTag("")) return process
def customise_HcalPhase1(process): #common stuff process.load("CalibCalorimetry/HcalPlugins/Hcal_Conditions_forGlobalTag_cff") process.es_hardcode.toGet = cms.untracked.vstring( 'GainWidths', 'MCParams', 'RecoParams', 'RespCorrs', 'QIEData', 'Gains', 'Pedestals', 'PedestalWidths', 'ChannelQuality', 'ZSThresholds', 'TimeCorrs', 'LUTCorrs', 'LutMetadata', 'L1TriggerObjects', 'PFCorrs', 'ElectronicsMap', 'CholeskyMatrices', 'CovarianceMatrices' ) process.es_hardcode.hcalTopologyConstants.mode=cms.string('HcalTopologyMode::SLHC') process.es_hardcode.hcalTopologyConstants.maxDepthHB=cms.int32(3) process.es_hardcode.hcalTopologyConstants.maxDepthHB=cms.int32(3) process.es_hardcode.hcalTopologyConstants.maxDepthHE=cms.int32(5) process.es_hardcode.HcalReLabel.RelabelHits=cms.untracked.bool(True) # Special Upgrade trick (if absent - regular case assumed) process.es_hardcode.GainWidthsForTrigPrims = cms.bool(True) process.es_hardcode.HEreCalibCutoff = cms.double(100.) #for aging process.hcalTopologyIdeal.hcalTopologyConstants.mode=cms.string('HcalTopologyMode::SLHC') process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHB=cms.int32(3) process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHE=cms.int32(5) if hasattr(process,'g4SimHits'): process=customise_Sim(process) if hasattr(process,'DigiToRaw'): process=customise_DigiToRaw(process) if hasattr(process,'RawToDigi'): process=customise_RawToDigi(process) if hasattr(process,'digitisation_step'): process=customise_Digi(process) if hasattr(process,'reconstruction_step'): process=customise_Reco(process) if hasattr(process,'dqmoffline_step'): process=customise_DQM(process) if hasattr(process,'dqmHarvesting'): process=customise_harvesting(process) if hasattr(process,'validation_step'): process=customise_Validation(process) process=customise_condOverRides(process) return process
def _modifyHcalSimParametersForPostLS1( object ) : """ Customises the HCal digitiser for post LS1 running """ object.ho.photoelectronsToAnalog = cms.vdouble([4.0]*16) object.ho.siPMCode = cms.int32(1) object.ho.pixels = cms.int32(2500) object.ho.doSiPMSmearing = cms.bool(False) object.hf1.samplingFactor = cms.double(0.60) object.hf2.samplingFactor = cms.double(0.60)
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 customise(process): process.simHcalUnsuppressedDigis.doThermalNoise = cms.bool(False) #process.simSiStripDigis.CommonModeNoise = cms.bool(False) #process.simSiStripDigis.SingleStripNoise = cms.bool(False) #process.simSiStripDigis.Noise = cms.bool(False) #process.simSiPixelDigis.AddNoise = cms.bool(False) #process.simMuonRPCDigis.Noise = cms.bool(False) #process.simMuonCSCDigis.strips.doCorrelatedNoise = cms.bool(False) #process.simMuonCSCDigis.wires.doNoise = cms.bool(False) #process.simMuonCSCDigis.strips.doNoise = cms.bool(False) process.simEcalUnsuppressedDigis. doESNoise = cms.bool(False) process.simCastorDigis. doNoise = cms.bool(False) process.simEcalUnsuppressedDigis. doNoise = cms.bool(False) process.simHcalUnsuppressedDigis. doNoise = cms.bool(False) process.TFileService = cms.Service("TFileService", fileName = cms.string("histo.root"), closeFileFast = cms.untracked.bool(True) ) from TrackingTools.TrackAssociator.default_cfi import TrackAssociatorParameterBlock myBlock=TrackAssociatorParameterBlock.clone() myBlock.TrackAssociatorParameters.usePreshower = cms.bool(True) process.ana = cms.EDProducer('MuonCaloCleaner', myBlock, selectedMuons = cms.InputTag("muons"), storeDeps = cms.untracked.bool(True) ) process.anaPlus = cms.EDAnalyzer("AnaMuonCaloCleaner", colLen = cms.InputTag("ana", "plus"), colDep = cms.InputTag("ana", "plusDeposits"), selectedMuons = cms.InputTag("muons"), charge = cms.int32(1) ) process.anaMinus = cms.EDAnalyzer("AnaMuonCaloCleaner", colLen = cms.InputTag("ana", "minus"), colDep = cms.InputTag("ana", "minusDeposits"), selectedMuons = cms.InputTag("muons"), charge = cms.int32(-1) ) process.mySeq = cms.Sequence(process.ProductionFilterSequence*process.ana*process.anaPlus*process.anaMinus) process.myPath = cms.Path(process.mySeq) process.schedule.extend([process.myPath]) process.MessageLogger.cerr.FwkReport.reportEvery = 100 return process
def customiseDataRun2Common_50nsRunsAfter253000(process): process = customiseDataRun2Common_withStage1(process) if hasattr(process,'particleFlowClusterECAL'): process.particleFlowClusterECAL.energyCorrector.autoDetectBunchSpacing = False process.particleFlowClusterECAL.energyCorrector.bunchSpacing = cms.int32(50) if hasattr(process,'ecalMultiFitUncalibRecHit'): process.ecalMultiFitUncalibRecHit.algoPSet.useLumiInfoRunHeader = False process.ecalMultiFitUncalibRecHit.algoPSet.bunchSpacing = cms.int32(50) return process
def customise(process): process.hcalTopologyIdeal.hcalTopologyConstants.mode = cms.string("HcalTopologyMode::SLHC") process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHB = cms.int32(7) process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHE = cms.int32(7) process.hcalTopologyIdeal.hcalTopologyConstants = cms.PSet(hcalTopologyConstants_cfi.hcalTopologyConstants) process.es_hardcode.hcalTopologyConstants = cms.PSet(hcalTopologyConstants_cfi.hcalTopologyConstants) process.CaloTowerHardcodeGeometryEP = cms.PSet(hcalTopologyConstants_cfi.hcalTopologyConstants) return process
conversionTrackProducers = cms.Sequence( generalConversionTrackProducer * conversionStepConversionTrackProducer * inOutConversionTrackProducer * outInConversionTrackProducer * gsfConversionTrackProducer) #merge generalTracks and conversionStepTracks collections, with arbitration by nhits then chi^2/ndof for ecalseededarbitrated, mergedarbitratedecalgeneral and mergedarbitrated flags generalConversionStepConversionTrackMerger = RecoEgamma.EgammaPhotonProducers.conversionTrackMerger_cfi.conversionTrackMerger.clone( TrackProducer1=cms.string('generalConversionTrackProducer'), TrackProducer2=cms.string('conversionStepConversionTrackProducer'), #prefer collection settings: #-1: propagate output/flag from both input collections # 0: propagate output/flag from neither input collection # 1: arbitrate output/flag (remove duplicates by shared hits), give precedence to first input collection # 2: arbitrate output/flag (remove duplicates by shared hits), give precedence to second input collection # 3: arbitrate output/flag (remove duplicates by shared hits), arbitration first by number of hits, second by chisq/ndof arbitratedMergedPreferCollection=cms.int32(3), arbitratedMergedEcalGeneralPreferCollection=cms.int32(3), ) #merge two ecal-seeded collections, with arbitration by nhits then chi^2/ndof for ecalseededarbitrated, mergedarbitratedecalgeneral and mergedarbitrated flags inOutOutInConversionTrackMerger = RecoEgamma.EgammaPhotonProducers.conversionTrackMerger_cfi.conversionTrackMerger.clone( TrackProducer1=cms.string('inOutConversionTrackProducer'), TrackProducer2=cms.string('outInConversionTrackProducer'), #prefer collection settings: #-1: propagate output/flag from both input collections # 0: propagate output/flag from neither input collection # 1: arbitrate output/flag (remove duplicates by shared hits), give precedence to first input collection # 2: arbitrate output/flag (remove duplicates by shared hits), give precedence to second input collection # 3: arbitrate output/flag (remove duplicates by shared hits), arbitration first by number of hits, second by chisq/ndof arbitratedEcalSeededPreferCollection=cms.int32(3), arbitratedMergedPreferCollection=cms.int32(3),
ParameterValue = cms.vstring("TI","TO","TP","TM"), ), cms.PSet( ParameterName = cms.string("defaultPhases"), ParameterType = cms.string("vint32"), ParameterValue = cms.vint32(63,63,63,63), ), cms.PSet( ParameterName = cms.string("useEC0"), ParameterType = cms.string("bool"), ParameterValue = cms.bool(False), ), cms.PSet( ParameterName = cms.string("badRun"), ParameterType = cms.string("bool"), ParameterValue = cms.bool(False), ), cms.PSet( ParameterName = cms.string("magicOffset"), ParameterType = cms.string("int"), ParameterValue = cms.int32(8), ), ) siStripConfObjectAPVPhaseOffsetsFakeESSource = cms.ESSource("SiStripConfObjectFakeESSource", appendToDataLabel = cms.string('apvphaseoffsets') )
), ecal = cms.PSet( ecalDigitizer ), hcal = cms.PSet( hcalDigitizer ), castor = cms.PSet( castorDigitizer ), mergedtruth = cms.PSet( trackingParticles ) ), LabelPlayback = cms.string(''), maxBunch = cms.int32(2), minBunch = cms.int32(-3), ## in 50ns spacing, go 150ns into past bunchspace = cms.int32(50), ##ns mixProdStep1 = cms.bool(False), mixProdStep2 = cms.bool(False), playback = cms.untracked.bool(False), useCurrentProcessOnly = cms.bool(False), input = cms.SecSource("PoolSource", nbPileupEvents = cms.PSet( averageNumber = cms.double(10.0) ), type = cms.string('poisson'), sequential = cms.untracked.bool(False),
#process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff') process.load('Configuration.StandardSequences.GeometryRecoDB_cff') process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_condDBv2_cff') from Configuration.AlCa.GlobalTag import GlobalTag if runOnMC: process.GlobalTag.globaltag = '102X_upgrade2018_realistic_v20'#'MCRUN2_74_V9::All' elif not(runOnMC): process.GlobalTag.globaltag = '102X_dataRun2_Prompt_v15' hltFiltersProcessName = 'RECO' if runOnMC: hltFiltersProcessName = 'PAT' #'RECO' #if DOHLTFILTERS and not(runOnMC): process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi') process.HBHENoiseFilterResultProducer.minZeros = cms.int32(99999) process.HBHENoiseFilterResultProducer.IgnoreTS4TS5ifJetInLowBVRegion=cms.bool(False) process.HBHENoiseFilterResultProducer.defaultDecision = cms.string("HBHENoiseFilterResultRun2Loose") process.ApplyBaselineHBHENoiseFilter = cms.EDFilter('BooleanFlagFilter', inputLabel = cms.InputTag('HBHENoiseFilterResultProducer','HBHENoiseFilterResult'), reverseDecision = cms.bool(False) ) process.ApplyBaselineHBHEIsoNoiseFilter = cms.EDFilter('BooleanFlagFilter', inputLabel = cms.InputTag('HBHENoiseFilterResultProducer','HBHEIsoNoiseFilterResult'), reverseDecision = cms.bool(False) ) process.load('RecoMET.METFilters.ecalBadCalibFilter_cfi') from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer baddetEcallist = cms.vuint32(
HcalTDCFED = cms.untracked.int32(8), HcalQADCFED = cms.untracked.int32(8), HcalSlowDataFED = cms.untracked.int32(3), HcalTriggerFED = cms.untracked.int32(1), HcalVLSBFED = cms.untracked.int32(699), ConfigurationFile = cms.untracked.string('configQADCTDC_TB2009.txt') ) process.hcalDigis = cms.EDFilter("HcalRawToDigi", UnpackZDC = cms.untracked.bool(True), FilterDataQuality = cms.bool(True), ExceptionEmptyData = cms.untracked.bool(True), InputLabel = cms.InputTag("source"), ComplainEmptyData = cms.untracked.bool(False), UnpackCalib = cms.untracked.bool(False), firstSample = cms.int32(0), lastSample = cms.int32(9), FEDs = cms.untracked.vint32(21), HcalFirstFED = cms.untracked.int32(21) ) process.load("RecoLocalCalo.HcalRecProducers.HcalSimpleReconstructor_hbhe_cfi") process.hbhereco.firstSample = 5 process.hbhereco.samplesToAdd = 4 process.options = cms.untracked.PSet( Rethrow = cms.untracked.vstring('ProductNotFound', 'TooManyProducts', 'TooFewProducts') ) process.triggerfilter = cms.EDFilter("TriggerFilter",
from Configuration.Generator.PyquenTuneZ2Settings_cff import * hiSignal = cms.EDFilter("PyquenGeneratorFilter", collisionParameters, qgpParameters, pyquenParameters, bFixed = cms.double(0.0), ## fixed impact param (fm); valid only if cflag_=0 PythiaParameters = cms.PSet(pyquenPythiaDefaultBlock, parameterSets = cms.vstring('pythiaUESettings', 'ppJets', 'kinematics'), kinematics = cms.vstring ("CKIN(3)=30", #min pthat "CKIN(4)=9999" #max pthat ) ), cFlag = cms.int32(0), ## centrality flag bMin = cms.double(0.0), ## min impact param (fm); valid only if cflag_!=0 bMax = cms.double(0.0) ## max impact param (fm); valid only if cflag_!=0 ) hiSignal.doQuench = cms.bool(False) hiSignal.doIsospin = cms.bool(False) hiSignal.protonSide = cms.untracked.int32(0) hiSignal.embeddingMode = True configurationMetadata = cms.untracked.PSet( version = cms.untracked.string('$Revision: 1.5 $'), name = cms.untracked.string('$Source: /cvs_server/repositories/CMSSW/CMSSW/Configuration/GenProduction/python/HI/Pyquen_Dijet30_pp_Unquenched_TuneZ2_5p02TeV_cff.py,v $'), annotation = cms.untracked.string('PYQUEN UNquenched dijets (pt-hat > 30 GeV) at sqrt(s) = 5.02TeV') )
import FWCore.ParameterSet.Config as cms from GeneratorInterface.ReggeGribovPartonMCInterface.ReggeGribovPartonMC_AdvancedParameters_cfi import * generator = cms.EDFilter( "ReggeGribovPartonMCGeneratorFilter", ReggeGribovPartonMCAdvancedParameters, beammomentum=cms.double(2510), targetmomentum=cms.double(-2510), beamid=cms.int32(1), targetid=cms.int32(208), model=cms.int32(0), ) configurationMetadata = cms.untracked.PSet( version=cms.untracked.string('$Revision: 1.4 $'), name=cms.untracked.string( '$Source: /local/reps/CMSSW/CMSSW/GeneratorInterface/ReggeGribovPartonMCInterface/python/ReggeGribovPartonMC_EposLHC_5TeV_pPb_cfi.py,v $' ), annotation=cms.untracked.string('ReggeGribovMC generator')) particlefilter = cms.EDFilter( "PythiaFilter", Status=cms.untracked.int32(1), MaxRapidity=cms.untracked.double(2.4), MinRapidity=cms.untracked.double(-2.4), MinPt=cms.untracked.double(5.9), MaxPt=cms.untracked.double(999.), ParticleID=cms.untracked.int32(3312), ) ProductionFilterSequence = cms.Sequence(generator + particlefilter)
#--------------- # Input sources if unitTest: process.load("DQM.Integration.config.unittestinputsource_cfi") from DQM.Integration.config.unittestinputsource_cfi import options elif live: process.load("DQM.Integration.config.inputsource_cfi") from DQM.Integration.config.inputsource_cfi import options else: process.load("DQM.Integration.config.fileinputsource_cfi") from DQM.Integration.config.fileinputsource_cfi import options #-------------------------- # HLT Filter process.hltTriggerTypeFilter = cms.EDFilter("HLTTriggerTypeFilter", SelectedTriggerType = cms.int32(1) # physics ) #---------------------------- # DQM Live Environment process.load("DQM.Integration.config.environment_cfi") process.dqmEnv.subSystemFolder = 'BeamMonitor' process.dqmSaver.tag = 'BeamMonitor' process.dqmSaver.runNumber = options.runNumber process.dqmSaverPB.tag = 'BeamMonitor' process.dqmSaverPB.runNumber = options.runNumber process.dqmEnvPixelLess = process.dqmEnv.clone() process.dqmEnvPixelLess.subSystemFolder = 'BeamMonitor_PixelLess' #---------------
MaxEta=cms.double(0.5655), MinPhi=cms.double(0.1309), MaxPhi=cms.double(0.1309), BeamPosition=cms.double(-408.50)) from IOMC.EventVertexGenerators.VtxSmearedParameters_cfi import * process.VtxSmeared = cms.EDProducer("BeamProfileVtxGenerator", process.common_beam_direction_parameters, VtxSmearedCommon, BeamMeanX=cms.double(0.0), BeamMeanY=cms.double(0.0), BeamSigmaX=cms.double(0.0001), BeamSigmaY=cms.double(0.0001), Psi=cms.double(999.9), GaussianProfile=cms.bool(False), BinX=cms.int32(50), BinY=cms.int32(50), File=cms.string('beam.profile'), UseFile=cms.bool(False), TimeOffset=cms.double(0.)) process.source = cms.Source("EmptySource", firstRun=cms.untracked.uint32(1), firstEvent=cms.untracked.uint32(1)) process.generator = cms.EDProducer( "FlatRandomEGunProducer", PGunParameters=cms.PSet(process.common_beam_direction_parameters, MinE=cms.double(9.99), MaxE=cms.double(10.01), PartID=cms.vint32(211)),
recHits4DLabel = cms.InputTag('dt4DSegments'), rootFileName = cms.untracked.string('DTTMaxHistos.root'), debug = cms.untracked.bool(False), # Choose the chamber you want to calibrate (default = "All"), specify the chosen chamber # in the format "wheel station sector" (i.e. "-1 3 10") calibChamber = cms.untracked.string('All'), # Chosen granularity (N.B. bySL is the only one implemented at the moment) tMaxGranularity = cms.untracked.string('bySL'), # The module to be used for ttrig synchronization and its set parameter tTrigMode = cms.string('DTTTrigSyncFromDB'), tTrigModeConfig = cms.PSet( # The velocity of signal propagation along the wire (cm/ns) vPropWire = cms.double(24.4), # Switch on/off the TOF correction for particles doTOFCorrection = cms.bool(False), tofCorrType = cms.int32(0), wirePropCorrType = cms.int32(0), # Switch on/off the correction for the signal propagation along the wire doWirePropCorrection = cms.bool(False), # Switch on/off the TO correction from pulses doT0Correction = cms.bool(True), debug = cms.untracked.bool(False), tTrigLabel = cms.string('cosmics') ), # Choose to calculate vDrift and t0 or just fill the TMax histograms findVDriftAndT0 = cms.untracked.bool(False), # Parameter set for DTCalibrationMap constructor calibFileConfig = cms.untracked.PSet( nFields = cms.untracked.int32(6), calibConstGranularity = cms.untracked.string('bySL'), calibConstFileName = cms.untracked.string('vDriftAndReso.txt')
import FWCore.ParameterSet.Config as cms from RecoMET.METFilters.CSCTightHaloFilter_cfi import * CSCTightHaloFilter.taggingMode = cms.bool(True) from RecoMET.METFilters.eeBadScFilter_cfi import * eeBadScFilter.taggingMode = cms.bool(True) primaryVertexFilter = cms.EDFilter( "GoodVertexFilter", vertexCollection=cms.InputTag('offlinePrimaryVertices'), minimumNDOF=cms.uint32(4), maxAbsZ=cms.double(15), maxd0=cms.double(2), filter=cms.bool(False)) from CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi import * HBHENoiseFilterResultProducer.minZeros = cms.int32(99999) from RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi import * EcalDeadCellTriggerPrimitiveFilter.taggingMode = cms.bool(True) ggMETFiltersSequence = cms.Sequence( CSCTightHaloFilter * HBHENoiseFilterResultProducer * primaryVertexFilter * eeBadScFilter * EcalDeadCellTriggerPrimitiveFilter)
import FWCore.ParameterSet.Config as cms PFJetParameters = cms.PSet( src=cms.InputTag('particleFlow'), srcPVs=cms.InputTag(''), jetType=cms.string('PFJet'), jetPtMin=cms.double(5.0), inputEMin=cms.double(0.0), inputEtMin=cms.double(0.0), doPVCorrection=cms.bool(False), # pileup with offset correction doPUOffsetCorr=cms.bool(False), # if pileup is false, these are not read: #nSigmaPU = cms.double(1.0), #radiusPU = cms.double(0.5), # fastjet-style pileup doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(False), doAreaDiskApprox=cms.bool(False), Active_Area_Repeats=cms.int32(1), GhostArea=cms.double(0.01), Ghost_EtaMax=cms.double(5.0), Rho_EtaMax=cms.double(4.4), voronoiRfact=cms.double(-0.9), useDeterministicSeed=cms.bool(True), minSeed=cms.uint32(14327), applyWeight=cms.bool(False))
import FWCore.ParameterSet.Config as cms from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer dtTriggerSynchMonitor = DQMEDAnalyzer('DTLocalTriggerSynchTask', staticBooking = cms.untracked.bool(True), # labels of DDU/TM data and 4D segments TMInputTag = cms.InputTag('dttfDigis'), DDUInputTag = cms.InputTag('muonDTDigis'), SEGInputTag = cms.InputTag('dt4DSegments'), processDDU = cms.untracked.bool(True), bxTimeInterval = cms.double(25), rangeWithinBX = cms.bool(True), nBXHigh = cms.int32(0), nBXLow = cms.int32(1), angleRange = cms.double(30.), minHitsPhi = cms.int32(7), baseDir = cms.string("DT/90-LocalTriggerSynch/"), tTrigModeConfig = cms.PSet( vPropWire = cms.double(24.4), doTOFCorrection = cms.bool(False), tofCorrType = cms.int32(0), wirePropCorrType = cms.int32(0), doWirePropCorrection = cms.bool(False), doT0Correction = cms.bool(False), debug = cms.untracked.bool(False), tTrigLabel = cms.string('') ), tTrigMode = cms.string('DTTTrigSyncFromDB') ) from Configuration.Eras.Modifier_run2_DT_2018_cff import run2_DT_2018
if unitTest == True: process.load("DQM.Integration.config.unittestinputsource_cfi") from DQM.Integration.config.unittestinputsource_cfi import options else: process.load("DQM.Integration.config.inputsource_cfi") from DQM.Integration.config.inputsource_cfi import options # Use this to run locally (for testing purposes) #process.load("DQM.Integration.config.fileinputsource_cfi") #from DQM.Integration.config.fileinputsource_cfi import options #---------------------------- # HLT Filter #---------------------------- # 0=random, 1=physics, 2=calibration, 3=technical process.hltTriggerTypeFilter = cms.EDFilter("HLTTriggerTypeFilter", SelectedTriggerType = cms.int32(1)) #---------------------------- # DQM Environment #---------------------------- process.load("DQM.Integration.config.environment_cfi") process.dqmEnv.subSystemFolder = "BeamPixel" process.dqmSaver.tag = "BeamPixel" process.dqmSaver.runNumber = options.runNumber process.dqmSaverPB.tag = 'BeamPixel' process.dqmSaverPB.runNumber = options.runNumber #---------------------------- # Conditions #----------------------------
import FWCore.ParameterSet.Config as cms phase2trackClusterRemover = cms.EDProducer( 'TrackClusterRemoverPhase2', trajectories=cms.InputTag(''), trackClassifier=cms.InputTag('', 'QualityMasks'), phase2pixelClusters=cms.InputTag('siPixelClusters'), phase2OTClusters=cms.InputTag('siPhase2Clusters'), oldClusterRemovalInfo=cms.InputTag(''), TrackQuality=cms.string('highPurity'), maxChi2=cms.double(30), minNumberOfLayersWithMeasBeforeFiltering=cms.int32(0), overrideTrkQuals=cms.InputTag(''))
import FWCore.ParameterSet.Config as cms generalTpSelectorBlock = cms.PSet(lip=cms.double(30.0), chargedOnly=cms.bool(True), pdgId=cms.vint32(), signalOnly=cms.bool(True), intimeOnly=cms.bool(False), stableOnly=cms.bool(False), minRapidity=cms.double(-2.5), minHit=cms.int32(0), ptMin=cms.double(0.9), ptMax=cms.double(1e100), maxRapidity=cms.double(2.5), tip=cms.double(2.0), minPhi=cms.double(-3.2), maxPhi=cms.double(3.2), invertRapidityCut=cms.bool(False)) from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toModify(generalTpSelectorBlock, stableOnly=True) TpSelectorForEfficiencyVsEtaBlock = generalTpSelectorBlock.clone() TpSelectorForEfficiencyVsPhiBlock = generalTpSelectorBlock.clone() TpSelectorForEfficiencyVsPtBlock = generalTpSelectorBlock.clone(ptMin=0.050) TpSelectorForEfficiencyVsVTXRBlock = generalTpSelectorBlock.clone(tip=60.0) TpSelectorForEfficiencyVsVTXZBlock = generalTpSelectorBlock.clone() def _modifyForPhase1(pset): pset.minRapidity = -3 pset.maxRapidity = 3
deltaSignificanceCut=cms.untracked.double(10)), PVFitter=cms.PSet( Debug=cms.untracked.bool(False), Apply3DFit=cms.untracked.bool(True), VertexCollection=cms.untracked.InputTag('offlinePrimaryVertices'), #WriteAscii = cms.untracked.bool(True), #AsciiFileName = cms.untracked.string('PVFit.txt'), maxNrStoredVertices=cms.untracked.uint32(10000), minNrVerticesForFit=cms.untracked.uint32(50), minVertexNdf=cms.untracked.double(10.), maxVertexNormChi2=cms.untracked.double(10.), minVertexNTracks=cms.untracked.uint32(0), minVertexMeanWeight=cms.untracked.double(0.5), maxVertexR=cms.untracked.double(2), maxVertexZ=cms.untracked.double(10), errorScale=cms.untracked.double(0.9), nSigmaCut=cms.untracked.double(5.), FitPerBunchCrossing=cms.untracked.bool(True)), dxBin=cms.int32(200), dxMin=cms.double(-1.0), dxMax=cms.double(1.0), vxBin=cms.int32(200), vxMin=cms.double(-0.5), vxMax=cms.double(0.5), dzBin=cms.int32(80), dzMin=cms.double(-20), dzMax=cms.double(20), phiBin=cms.int32(63), phiMin=cms.double(-3.15), phiMax=cms.double(3.15))
process.FEVTDEBUGHLToutput = cms.OutputModule( "PoolOutputModule", dataset=cms.untracked.PSet( dataTier=cms.untracked.string('GEN-SIM-DIGI-RAW'), filterName=cms.untracked.string('')), eventAutoFlushCompressedSize=cms.untracked.int32(10485760), fileName=cms.untracked.string('file:step2.root'), outputCommands=process.FEVTDEBUGHLTEventContent.outputCommands, splitLevel=cms.untracked.int32(0)) # Additional output definition # Other statements process.mix.input.nbPileupEvents.averageNumber = cms.double(200.000000) process.mix.bunchspace = cms.int32(25) process.mix.minBunch = cms.int32(-3) process.mix.maxBunch = cms.int32(3) process.mix.input.fileNames = cms.untracked.vstring([ '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_1.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_10.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_100.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_11.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_12.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_13.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_14.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_15.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_16.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_17.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_18.root', '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_19.root',
veto=cms.double(0.699), ), ### cms.PSet( ### algo=cms.string("DiphotonsFootPrintRemovedIsolationAlgo"), ### name=cms.string("fpr03"), ### coneSize=cms.double(0.3), doRandomCone=cms.bool(False), removePhotonsInMap=cms.int32(1), ### rechitLinkEnlargement=cms.double(0.25), ### charged=cms.vdouble(0.02,0.02,0.1), ### photon=cms.vdouble(0.0, 0.070, 0.015, 0.0, 0.0, 0.0), ### ), cms.PSet( algo=cms.string("DiphotonsFootPrintRemovedIsolationAlgo"), name=cms.string("fprNoMap03"), coneSize=cms.double(0.3), doRandomCone=cms.bool(False), removePhotonsInMap=cms.int32(0), rechitLinkEnlargement=cms.double(0.25), photon=cms.vdouble(0.0, 0.070, 0.015, 0.0, 0.0, 0.0), charged=cms.vdouble(0.02, 0.02, 0.1), ), #### cms.PSet( #### algo=cms.string("DiphotonsFootPrintRemovedIsolationAlgo"), #### name=cms.string("fprRnd03"), #### coneSize=cms.double(0.3), doRandomCone=cms.bool(True), removePhotonsInMap=cms.int32(1), #### rechitLinkEnlargement=cms.double(0.25), #### charged=cms.vdouble(0.02,0.02,0.1), #### vetoCollections_=cms.VInputTag(cms.InputTag("vetoPhotons"),cms.InputTag("vetoJets")), #### veto=cms.double(0.699), #### ), ])
process.load('ISpy.Analyzers.ISpyRPCRecHit_cfi') process.load('ISpy.Analyzers.ISpySiPixelCluster_cfi') process.load('ISpy.Analyzers.ISpySiPixelRecHit_cfi') process.load('ISpy.Analyzers.ISpySiStripCluster_cfi') process.load('ISpy.Analyzers.ISpySiStripDigi_cfi') process.load('ISpy.Analyzers.ISpySuperCluster_cfi') process.load('ISpy.Analyzers.ISpyTrack_cfi') process.load('ISpy.Analyzers.ISpyTrackingRecHit_cfi') process.load('ISpy.Analyzers.ISpyTriggerEvent_cfi') process.load('ISpy.Analyzers.ISpyVertex_cfi') process.ISpyBasicCluster.iSpyBasicClusterTag = cms.InputTag("hybridSuperClusters:hybridBarrelBasicClusters") process.ISpyCSCRecHit2D.iSpyCSCRecHit2DTag = cms.InputTag("csc2DRecHits") process.ISpyCSCSegment.iSpyCSCSegmentTag = cms.InputTag("cscSegments") process.ISpyCSCStripDigi.iSpyCSCStripDigiTag = cms.InputTag('muonCSCDigis:MuonCSCStripDigi') process.ISpyCSCStripDigi.thresholdOffset = cms.int32(9) process.ISpyCSCWireDigi.iSpyCSCWireDigiTag = cms.InputTag('muonCSCDigis:MuonCSCWireDigi') process.ISpyCaloCluster.iSpyCaloClusterTag = cms.InputTag("hybridSuperClusters:hybridBarrelBasicClusters") process.ISpyCaloTower.iSpyCaloTowerTag = cms.InputTag('towerMaker') process.ISpyCaloMET.iSpyCaloMETTag = cms.InputTag('met') process.ISpyCaloTau.iSpyCaloTauTag = cms.InputTag('caloRecoTauProducer') process.ISpyDTDigi.iSpyDTDigiTag = cms.InputTag('muonDTDigis') process.ISpyDTRecHit.iSpyDTRecHitTag = cms.InputTag('dt1DRecHits') process.ISpyDTRecSegment4D.iSpyDTRecSegment4DTag = cms.InputTag('dt4DSegments') process.ISpyEBRecHit.iSpyEBRecHitTag = cms.InputTag('ecalRecHit:EcalRecHitsEB') process.ISpyEERecHit.iSpyEERecHitTag = cms.InputTag('ecalRecHit:EcalRecHitsEE') process.ISpyESRecHit.iSpyESRecHitTag = cms.InputTag('ecalPreshowerRecHit:EcalRecHitsES') #process.ISpyElectron.iSpyElectronTag = cms.InputTag('hltPixelMatchElectronsL1Iso') process.ISpyGsfElectron.iSpyGsfElectronTag = cms.InputTag('gsfElectrons') process.ISpyGsfPFRecTrack.iSpyGsfPFRecTrackTag = cms.InputTag('pfTrackElec') process.ISpyGsfTrack.iSpyGsfTrackTag = cms.InputTag('electronGsfTracks')
ctppsDiamondDQMSource = cms.EDAnalyzer( "CTPPSDiamondDQMSource", tagStatus=cms.InputTag("ctppsDiamondRawToDigi", "TimingDiamond"), tagDigi=cms.InputTag("ctppsDiamondRawToDigi", "TimingDiamond"), tagFEDInfo=cms.InputTag("ctppsDiamondRawToDigi", "TimingDiamond"), tagDiamondRecHits=cms.InputTag("ctppsDiamondRecHits"), tagDiamondLocalTracks=cms.InputTag("ctppsDiamondLocalTracks"), tagLocalTrack=cms.InputTag("totemRPLocalTrackFitter"), excludeMultipleHits=cms.bool(True), minimumStripAngleForTomography=cms.double(0), maximumStripAngleForTomography=cms.double(1), offsetsOOT=cms.VPSet( # cut on the OOT bin for physics hits # 2016, after TS2 cms.PSet( validityRange=cms.EventRange("1:min - 292520:max"), centralOOT=cms.int32(1), ), # 2017 cms.PSet( validityRange=cms.EventRange("292521:min - 301417:max"), centralOOT=cms.int32(3), ), # 2017, after channel delays corrections cms.PSet( validityRange=cms.EventRange("301418:min - 301517:max"), centralOOT=cms.int32(1), ), # 2017, after channel delays corrections cms.PSet( validityRange=cms.EventRange("301518:min - 9999999:max"), centralOOT=cms.int32(0),
process.source = cms.Source("PoolSource", # replace 'myfile.root' with the source file you want to use fileNames = cms.untracked.vstring( '/store/hidata/HIRun2015/HIMinimumBias7/AOD/02May2016-v1/00000/089673D3-6199-E611-B9E9-1418774A30CD.root' ) ) process.load("Flow.V2Analyzer.v2analyzerCumulant_cfi") process.TFileService = cms.Service("TFileService",fileName = cms.string("vn_mainresult_cumulant_ver2.root")) process.demo_n1 = process.demo.clone( useCentrality = cms.bool(False), efftableName = cms.string('eff_1'), Nmin = cms.int32(90), Nmax = cms.int32(120), order = cms.int32(2), ) process.demo_n2 = process.demo.clone( useCentrality = cms.bool(False), efftableName = cms.string('eff_2'), Nmin = cms.int32(120), Nmax = cms.int32(150), order = cms.int32(2), ) process.demo_n3 = process.demo.clone( useCentrality = cms.bool(False),
import FWCore.ParameterSet.Config as cms DA_vectParameters = cms.PSet( algorithm=cms.string("DA_vect"), TkDAClusParameters=cms.PSet( coolingFactor=cms.double(0.6), # moderate annealing speed zrange=cms.double( 4.), # consider only clusters within 4 sigma*sqrt(T) of a track delta_highT=cms.double(1.e-2), # convergence requirement at high T delta_lowT=cms.double(1.e-3), # convergence requirement at low T convergence_mode=cms.int32( 0), # 0 = two steps, 1 = dynamic with sqrt(T) Tmin=cms.double(2.0), # end of vertex splitting Tpurge=cms.double(2.0), # cleaning Tstop=cms.double(0.5), # end of annealing vertexSize=cms.double( 0.006), # added in quadrature to track-z resolutions d0CutOff=cms.double(3.), # downweight high IP tracks dzCutOff=cms.double( 3.), # outlier rejection after freeze-out (T<Tmin) zmerge=cms.double( 1e-2), # merge intermediat clusters separated by less than zmerge uniquetrkweight=cms.double( 0.8), # require at least two tracks with this weight at T=Tpurge uniquetrkminp=cms.double( 0.0) # minimal a priori track weight for counting unique tracks )) from Configuration.Eras.Modifier_highBetaStar_2018_cff import highBetaStar_2018 highBetaStar_2018.toModify(DA_vectParameters, TkDAClusParameters=dict(Tmin=4.0,
import FWCore.ParameterSet.Config as cms import os source = cms.Source("EmptySource") generator = cms.EDFilter( "SherpaGeneratorFilter", maxEventsToPrint=cms.int32(0), filterEfficiency=cms.untracked.double(1.0), crossSection=cms.untracked.double(-1), SherpaProcess=cms.string('Znunugamma_aTGC_Zgg_h30p0_h4m0p0000006'), SherpackLocation=cms.string('./'), SherpackChecksum=cms.string('79e24b260d7fdb7e1a865b4e8637fad2'), FetchSherpack=cms.bool(False), SherpaPath=cms.string('./'), SherpaPathPiece=cms.string('./'), SherpaResultDir=cms.string('Result'), SherpaDefaultWeight=cms.double(1.0), SherpaParameters=cms.PSet( parameterSets=cms.vstring("MPI_Cross_Sections", "Run"), MPI_Cross_Sections=cms.vstring( " MPIs in Sherpa, Model = Amisic:", " semihard xsec = 37.4634 mb,", " non-diffractive xsec = 17.0318 mb with nd factor = 0.3142."), Run=cms.vstring( " (run){", " EVENTS = 1; ERROR 0.1;", " FSF:=1.; RSF:=1.; QSF:=1.;", " SCALES STRICT_METS{FSF*MU_F2}{RSF*MU_R2}{QSF*MU_Q2};", " ME_SIGNAL_GENERATOR Comix;", " EVENT_GENERATION_MODE PartiallyUnweighted;", " MASSIVE[5] 1", " MASSIVE[4] 1", " BEAM_1 2212; BEAM_ENERGY_1 6500.;", " BEAM_2 2212; BEAM_ENERGY_2 6500.;",
import FWCore.ParameterSet.Config as cms ckfBaseTrajectoryFilterP5 = cms.PSet( ComponentType=cms.string('CkfBaseTrajectoryFilter'), chargeSignificance=cms.double(-1.0), constantValueForLostHitsFractionFilter=cms.double(2.0), extraNumberOfHitsBeforeTheFirstLoop=cms.int32(4), maxCCCLostHits=cms.int32(9999), maxConsecLostHits=cms.int32(3), maxLostHits=cms.int32(4), maxLostHitsFraction=cms.double(0.1), maxNumberOfHits=cms.int32(100), minGoodStripCharge=cms.PSet( refToPSet_=cms.string('SiStripClusterChargeCutNone')), minHitsMinPt=cms.int32(3), minNumberOfHitsForLoopers=cms.int32(13), minNumberOfHitsPerLoop=cms.int32(4), minPt=cms.double(0.5), minimumNumberOfHits=cms.int32(5), nSigmaMinPt=cms.double(5.0), pixelSeedExtension=cms.bool(False), seedExtension=cms.int32(0), seedPairPenalty=cms.int32(0), strictSeedExtension=cms.bool(False))
workingPoints = dict( wpLoose = MVA_WPLoose ) # # Finally, set up VID configuration for all cuts # # Create the PSet that will be fed to the MVA value map producer mvaEleID_Spring16_HZZ_V1_producer_config = cms.PSet( mvaName = cms.string(mvaClassName), mvaTag = cms.string(mvaTag), # Category parameters nCategories = cms.int32(6), categoryCuts = cms.vstring(*EleMVA_6CategoriesCuts), # Weight files and variable definitions weightFileNames = mvaSpring16WeightFiles_V1, variableDefinition = cms.string(mvaVariablesFile) ) # Create the VPset's for VID cuts mvaEleID_Spring16_HZZ_V1_wpLoose = configureVIDMVAEleID( MVA_WPLoose ) # The MD5 sum numbers below reflect the exact set of cut variables # and values above. If anything changes, one has to # 1) comment out the lines below about the registry, # 2) run "calculateMD5 <this file name> <one of the VID config names just above> # 3) update the MD5 sum strings below and uncomment the lines again. #
) process.GlobalTag.globaltag = cms.string( '80X_mcRun2_asymptotic_2016_TrancheIV_v6') #----------------------------- # ADD THE ANALYSIS MODULE #----------------------------- process.load('ExLep2017Tree.Selection.EventSelectors_cfi') process.myMiniTreeProducer.MCTruth.isData = cms.bool(isData) if isData: process.myMiniTreeProducer.MCTruth.sampleCode = cms.string("DATA") else: #for multi CRAB process.myMiniTreeProducer.MCTruth.sampleCode = cms.string( "ExLepMuMuZ_M4500") process.myMiniTreeProducer.minEventQualityToStore = cms.int32(1) ##https://github.com/cms-jet/JRDatabase/tree/master/textFiles/Fall17_V3_MC process.myMiniTreeProducer.Jets.resolutionsFile = cms.string( 'Fall17_V3_MC_PtResolution_AK8PF.txt') process.myMiniTreeProducer.Jets.scaleFactorsFile = cms.string( 'Fall17_V3_MC_SF_AK8PF.txt') process.myMiniTreeProducer.Trigger.source = cms.InputTag('TriggerResults::HLT') process.myMiniTreeProducer.Trigger.trigBits = cms.vstring( "HLT_IsoMu24", "HLT_IsoTkMu24", "HLT_Mu50", "HLT_TkMu50", "HLT_DoubleEle33", "HLT_Ele27_WPTight_Gsf") #------------------------------------------------------ # apply partial MET filters via trigger selection. # BadPFMuonFilter and BadChargedCandidateFilter are # run on fly through addMETFilters (process) #------------------------------------------------------
# Set up electron ID (VID framework) # https://twiki.cern.ch/twiki/bin/view/CMS/MultivariateElectronIdentificationRun2 from PhysicsTools.SelectorUtils.tools.vid_id_tools import * switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD) # define which IDs we want to produce and add them to the VID producer for idmod in [ 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_PHYS14_PU20bx25_nonTrig_V1_cff' ]: setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection) # Set up HBHE noise filter # https://twiki.cern.ch/twiki/bin/viewauth/CMS/MissingETOptionalFiltersRun2 print "Setting up HBHE noise filter" process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi') process.HBHENoiseFilterResultProducer.minZeros = cms.int32(99999) process.HBHENoiseFilterResultProducer.IgnoreTS4TS5ifJetInLowBVRegion = cms.bool( False) process.HBHENoiseFilterResultProducer.defaultDecision = cms.string( "HBHENoiseFilterResultRun2Loose") # Do not apply EDfilters for HBHE noise, the discriminators for them are saved into the ttree process.load("HiggsAnalysis/MiniAOD2TTree/PUInfo_cfi") process.load("HiggsAnalysis/MiniAOD2TTree/TopPt_cfi") process.load("HiggsAnalysis/MiniAOD2TTree/Tau_cfi") process.load("HiggsAnalysis/MiniAOD2TTree/Electron_cfi") process.load("HiggsAnalysis/MiniAOD2TTree/Muon_cfi") process.load("HiggsAnalysis/MiniAOD2TTree/Jet_cfi") process.load("HiggsAnalysis/MiniAOD2TTree/MET_cfi") process.load("HiggsAnalysis/MiniAOD2TTree/METNoiseFilter_cfi") process.METNoiseFilter.triggerResults = cms.InputTag(
import FWCore.ParameterSet.Config as cms stdCTAnaPset = cms.PSet( recoVertexCollection=cms.InputTag("offlinePrimaryVertices"), caloTowerCollection=cms.InputTag("towerMaker"), vtxSel=cms.int32(20), cutEt=cms.bool(True), etTh=cms.double(1.), etEmTh=cms.double(-999.), etHadTh=cms.double(-999.)) caloTowerAnalysis = cms.EDAnalyzer("CaloTowerAnalysis", stdCTAnaPset)
"nDump": cms.untracked.int32(0), "nDumpTracks": cms.untracked.int32(0), # "mintrkweight":cms.untracked.double(0.5), "uniquetrkweight": cms.double(0.8), "uniquetrkminp": cms.double(0.0), "zmerge": cms.double(1.e-2), "coolingFactor": cms.double(0.6), "Tmin": cms.double(0), # 0 = not set, use default "Tpurge": cms.double(0), "Tstop": cms.double(0), "vertexSize": cms.double(0.006), "vertexSizeTime": cms.double(0.008), "d0CutOff": cms.double(3.), "dzCutOff": cms.double(3.), "zrange": cms.double(4), "convergence_mode": cms.int32(0), "delta_lowT": cms.double(1.e-3), "delta_highT": cms.double(1.e-2), # track selection "maxNormalizedChi2": cms.double(10.0), "minPixelLayersWithHits": cms.int32(2), "minSiliconLayersWithHits": cms.int32(5), "maxD0Significance": cms.double(4.0), "minPt": cms.double(0.0), "maxEta": cms.double(2.4), "trackQuality": cms.string("any"), # track selection, experimental "maxDzError": cms.double(1.0), "maxD0Error": cms.double(1.0), # vertex selection "minNdof": cms.double(0.0),