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