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'))
