def testNoSchedule(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.a = cms.EDProducer("AProd")
process.b = cms.EDProducer("BProd")
process.c = cms.EDProducer("CProd")
process.d = cms.EDProducer("DProd")
process.m = cms.EDProducer("MProd")
process.n = cms.EDProducer("NProd")
process.r = cms.EDProducer("RProd")
process.s = cms.EDProducer("SProd")
process.t1 = cms.Task(process.m)
t2 = cms.Task(process.n)
process.f1 = cms.EDFilter("Filter")
process.f2 = cms.EDFilter("Filter2")
process.f3 = cms.EDFilter("Filter3")
process.f4 = cms.EDFilter("FIlter4")
process.out1 = cms.OutputModule("Output1")
process.out2 = cms.OutputModule("Output2")
process.analyzer1 = cms.EDAnalyzer("analyzerType1")
process.analyzer2 = cms.EDAnalyzer("analyzerType2")
process.p1 = cms.Path(process.a+process.b+process.f1+process.analyzer1+cms.ignore(process.d)+cms.ignore(process.f2))
process.p4 = cms.Path(process.a+process.f2+process.b+~process.f1+cms.ignore(process.f4))
process.p2 = cms.Path(process.a+process.b)
process.p3 = cms.Path(process.f1, process.t1, t2)
process.t3 = cms.Task(process.r)
process.t4 = cms.Task(process.s)
process.s1 = cms.Sequence(~process.a, process.t3)
process.p5 = cms.Path(process.b + process.s1, process.t4)
process.end1 = cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2+process.a+process.b+cms.ignore(process.f1))
process.end2 = cms.EndPath()
convertToUnscheduled(process)
self.assert_(hasattr(process,'p2'))
self.assert_(hasattr(process,'a'))
self.assert_(hasattr(process,'b'))
self.assert_(hasattr(process,'c'))
self.assert_(hasattr(process,'d'))
self.assert_(hasattr(process,'f1'))
self.assert_(hasattr(process,'f2'))
self.assert_(hasattr(process,'f3'))
self.assert_(hasattr(process,'f4'))
self.assert_(hasattr(process,'out1'))
self.assert_(hasattr(process,'out2'))
self.assert_(hasattr(process,'analyzer1'))
self.assert_(hasattr(process,'analyzer2'))
self.assertEqual(process.p1.dumpPython(None),'cms.Path(process.f1+process.analyzer1, cms.Task(process.a, process.b, process.d, process.f2))\n')
self.assertEqual(process.p2.dumpPython(None),'cms.Path(cms.Task(process.a, process.b))\n')
self.assertEqual(process.p3.dumpPython(None),'cms.Path(process.f1, cms.Task(process.m, process.n))\n')
self.assertEqual(process.p4.dumpPython(None),'cms.Path(process.f2+~process.f1, cms.Task(process.a, process.b, process.f4))\n')
self.assertEqual(process.p5.dumpPython(None),'cms.Path(cms.Task(process.a, process.b), cms.Task(process.r, process.s))\n')
self.assertEqual(process.end1.dumpPython(None),'cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2, cms.Task(process.a, process.b, process.f1))\n')
self.assertEqual(process.end2.dumpPython(None),'cms.EndPath()\n')
def testNoSchedule(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.a = cms.EDProducer("AProd")
process.b = cms.EDProducer("BProd")
process.c = cms.EDProducer("CProd")
process.d = cms.EDProducer("DProd")
process.m = cms.EDProducer("MProd")
process.n = cms.EDProducer("NProd")
process.r = cms.EDProducer("RProd")
process.s = cms.EDProducer("SProd")
process.t1 = cms.Task(process.m)
t2 = cms.Task(process.n)
process.f1 = cms.EDFilter("Filter")
process.f2 = cms.EDFilter("Filter2")
process.f3 = cms.EDFilter("Filter3")
process.f4 = cms.EDFilter("FIlter4")
process.out1 = cms.OutputModule("Output1")
process.out2 = cms.OutputModule("Output2")
process.analyzer1 = cms.EDAnalyzer("analyzerType1")
process.analyzer2 = cms.EDAnalyzer("analyzerType2")
process.p1 = cms.Path(process.a+process.b+process.f1+process.analyzer1+cms.ignore(process.d)+cms.ignore(process.f2))
process.p4 = cms.Path(process.a+process.f2+process.b+~process.f1+cms.ignore(process.f4))
process.p2 = cms.Path(process.a+process.b)
process.p3 = cms.Path(process.f1, process.t1, t2)
process.t3 = cms.Task(process.r)
process.t4 = cms.Task(process.s)
process.s1 = cms.Sequence(~process.a, process.t3)
process.p5 = cms.Path(process.b + process.s1, process.t4)
process.end1 = cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2+process.a+process.b+cms.ignore(process.f1))
process.end2 = cms.EndPath()
convertToUnscheduled(process)
self.assert_(hasattr(process,'p2'))
self.assert_(hasattr(process,'a'))
self.assert_(hasattr(process,'b'))
self.assert_(hasattr(process,'c'))
self.assert_(hasattr(process,'d'))
self.assert_(hasattr(process,'f1'))
self.assert_(hasattr(process,'f2'))
self.assert_(hasattr(process,'f3'))
self.assert_(hasattr(process,'f4'))
self.assert_(hasattr(process,'out1'))
self.assert_(hasattr(process,'out2'))
self.assert_(hasattr(process,'analyzer1'))
self.assert_(hasattr(process,'analyzer2'))
self.assertEqual(process.p1.dumpPython(),'cms.Path(process.f1+process.analyzer1, cms.Task(process.a, process.b, process.d, process.f2))\n')
self.assertEqual(process.p2.dumpPython(),'cms.Path(cms.Task(process.a, process.b))\n')
self.assertEqual(process.p3.dumpPython(),'cms.Path(process.f1, cms.Task(process.m, process.n))\n')
self.assertEqual(process.p4.dumpPython(),'cms.Path(process.f2+~process.f1, cms.Task(process.a, process.b, process.f4))\n')
self.assertEqual(process.p5.dumpPython(),'cms.Path(cms.Task(process.a, process.b), cms.Task(process.r, process.s))\n')
self.assertEqual(process.end1.dumpPython(),'cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2, cms.Task(process.a, process.b, process.f1))\n')
self.assertEqual(process.end2.dumpPython(),'cms.EndPath()\n')
def __call__(self, obj):
if isinstance(obj,_UnarySequenceOperator):
self.__lastCallUnary = True
elif obj.isLeaf() and isinstance(obj, cms.EDFilter) and not self.__lastCallUnary:
return cms.ignore(obj)
else:
self.__lastCallUnary = False
return obj
def __call__(self, obj):
if isinstance(obj, _UnarySequenceOperator):
self.__lastCallUnary = True
elif obj.isLeaf() and isinstance(
obj, cms.EDFilter) and not self.__lastCallUnary:
return cms.ignore(obj)
else:
self.__lastCallUnary = False
return obj
def getQualifiedModule(name,proc):
unqual_name = getUnqualifiedName(name)
p=getattr(proc,unqual_name)
if unqual_name != name:
if name[0] == '!':
p = ~p
elif name[0] == '-':
p = cms.ignore(p)
return p
def getQualifiedModule(name, proc):
unqual_name = getUnqualifiedName(name)
p = getattr(proc, unqual_name)
if unqual_name != name:
if name[0] == '!':
p = ~p
elif name[0] == '-':
p = cms.ignore(p)
return p
def customiseL1Seeds( process):
if hasattr(process,"HLT_IsoMu24_v4") :
print "[customiseL1Seeds] Add cms.Ignore() to IsoMu24 L1 related filters"
process.HLT_IsoMu24_v4.replace(process.hltL1sSingleMu22,cms.ignore(process.hltL1sSingleMu22))
process.HLT_IsoMu24_v4.replace(process.hltL1fL1sMu22L1Filtered0,cms.ignore(process.hltL1fL1sMu22L1Filtered0))
if hasattr(process,"HLT_IsoTkMu24_v4") :
print "[customiseL1Seeds] Add cms.Ignore() to IsoTkMu24 L1 related filters"
process.HLT_IsoTkMu24_v4.replace(process.hltL1sSingleMu22,cms.ignore(process.hltL1sSingleMu22))
process.HLT_IsoTkMu24_v4.replace(process.hltL1fL1sMu22L1Filtered0,cms.ignore(process.hltL1fL1sMu22L1Filtered0))
return process
def testWithSchedule(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.a = cms.EDProducer("AProd")
process.b = cms.EDProducer("BProd")
process.c = cms.EDProducer("CProd")
process.d = cms.EDProducer("DProd")
process.m = cms.EDProducer("MProd")
process.n = cms.EDProducer("NProd")
process.t1 = cms.Task(process.m)
t2 = cms.Task(process.n)
process.f1 = cms.EDFilter("Filter")
process.f2 = cms.EDFilter("Filter2")
process.f3 = cms.EDFilter("Filter3")
process.f4 = cms.EDFilter("Filter4")
process.out1 = cms.OutputModule("Output1")
process.out2 = cms.OutputModule("Output2")
process.analyzer1 = cms.EDAnalyzer("analyzerType1")
process.analyzer2 = cms.EDAnalyzer("analyzerType2")
process.p1 = cms.Path(process.a+process.b+cms.ignore(process.f1)+process.d+process.f2)
process.p4 = cms.Path(process.a+process.f2+process.b+~process.f1)
process.p2 = cms.Path(process.a+process.b)
process.p3 = cms.Path(process.f1)
process.p5 = cms.Path(process.a+process.f4) #not used on schedule
process.end1 = cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2+process.a+process.b+cms.ignore(process.f1))
process.end2 = cms.EndPath()
process.schedule = cms.Schedule(process.p1,process.p4,process.p2,process.p3,process.end1,process.end2,tasks=[process.t1,t2])
convertToUnscheduled(process)
self.assert_(hasattr(process,'p2'))
self.assert_(hasattr(process,'a'))
self.assert_(hasattr(process,'b'))
self.assert_(hasattr(process,'c'))
self.assert_(hasattr(process,'d'))
self.assert_(hasattr(process,'f1'))
self.assert_(hasattr(process,'f2'))
self.assert_(hasattr(process,'f3'))
self.assert_(hasattr(process,"f4"))
self.assert_(hasattr(process,"p5"))
self.assertEqual(process.p1.dumpPython(),'cms.Path(process.f2, cms.Task(process.a, process.b, process.d, process.f1))\n')
self.assertEqual(process.p2.dumpPython(),'cms.Path(cms.Task(process.a, process.b))\n')
self.assertEqual(process.p3.dumpPython(),'cms.Path(process.f1)\n')
self.assertEqual(process.p4.dumpPython(),'cms.Path(process.f2+~process.f1, cms.Task(process.a, process.b))\n')
self.assertEqual(process.p5.dumpPython(),'cms.Path(process.f4, cms.Task(process.a))\n')
self.assertEqual(process.end1.dumpPython(),'cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2, cms.Task(process.a, process.b, process.f1))\n')
self.assertEqual(process.end2.dumpPython(),'cms.EndPath()\n')
self.assertEqual([p for p in process.schedule],[process.p1,process.p4,process.p2,process.p3,process.end1,process.end2])
listOfTasks = list(process.schedule._tasks)
self.assertEqual(listOfTasks, [process.t1,t2])
def testWithSchedule(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.a = cms.EDProducer("AProd")
process.b = cms.EDProducer("BProd")
process.c = cms.EDProducer("CProd")
process.d = cms.EDProducer("DProd")
process.m = cms.EDProducer("MProd")
process.n = cms.EDProducer("NProd")
process.t1 = cms.Task(process.m)
t2 = cms.Task(process.n)
process.f1 = cms.EDFilter("Filter")
process.f2 = cms.EDFilter("Filter2")
process.f3 = cms.EDFilter("Filter3")
process.f4 = cms.EDFilter("Filter4")
process.out1 = cms.OutputModule("Output1")
process.out2 = cms.OutputModule("Output2")
process.analyzer1 = cms.EDAnalyzer("analyzerType1")
process.analyzer2 = cms.EDAnalyzer("analyzerType2")
process.p1 = cms.Path(process.a+process.b+cms.ignore(process.f1)+process.d+process.f2)
process.p4 = cms.Path(process.a+process.f2+process.b+~process.f1)
process.p2 = cms.Path(process.a+process.b)
process.p3 = cms.Path(process.f1)
process.p5 = cms.Path(process.a+process.f4) #not used on schedule
process.end1 = cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2+process.a+process.b+cms.ignore(process.f1))
process.end2 = cms.EndPath()
process.schedule = cms.Schedule(process.p1,process.p4,process.p2,process.p3,process.end1,process.end2,tasks=[process.t1,t2])
convertToUnscheduled(process)
self.assert_(hasattr(process,'p2'))
self.assert_(hasattr(process,'a'))
self.assert_(hasattr(process,'b'))
self.assert_(hasattr(process,'c'))
self.assert_(hasattr(process,'d'))
self.assert_(hasattr(process,'f1'))
self.assert_(hasattr(process,'f2'))
self.assert_(hasattr(process,'f3'))
self.assert_(hasattr(process,"f4"))
self.assert_(hasattr(process,"p5"))
self.assertEqual(process.p1.dumpPython(None),'cms.Path(process.f2, cms.Task(process.a, process.b, process.d, process.f1))\n')
self.assertEqual(process.p2.dumpPython(None),'cms.Path(cms.Task(process.a, process.b))\n')
self.assertEqual(process.p3.dumpPython(None),'cms.Path(process.f1)\n')
self.assertEqual(process.p4.dumpPython(None),'cms.Path(process.f2+~process.f1, cms.Task(process.a, process.b))\n')
self.assertEqual(process.p5.dumpPython(None),'cms.Path(process.f4, cms.Task(process.a))\n')
self.assertEqual(process.end1.dumpPython(None),'cms.EndPath(process.out1+process.out2+process.analyzer1+process.analyzer2, cms.Task(process.a, process.b, process.f1))\n')
self.assertEqual(process.end2.dumpPython(None),'cms.EndPath()\n')
self.assertEqual([p for p in process.schedule],[process.p1,process.p4,process.p2,process.p3,process.end1,process.end2])
listOfTasks = list(process.schedule._tasks)
self.assertEqual(listOfTasks, [process.t1,t2])
def testIgnoreFiltersOnPath(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("Test")
process.f1 = cms.EDFilter("F1")
process.f2 = cms.EDFilter("F2")
process.f3 = cms.EDFilter("F3")
process.s = cms.Sequence(process.f3)
process.p = cms.Path(process.f1+cms.ignore(process.f2)+process.s)
ignoreAllFiltersOnPath(process.p)
self.assertEqual(process.p.dumpPython(None),'cms.Path(cms.ignore(process.f1)+cms.ignore(process.f2)+cms.ignore(process.f3))\n')
def addSkim(process, isData=False):
print "Adding Skim step."
print "triggerSelection should be verified for new datasets."
process.triggerSelection = cms.EDFilter( "TriggerResultsFilter",
triggerConditions = cms.vstring(
# Data: Run2015*
'HLT_PFHT800_v*',
# MC: RunIISpring15DR74
'HLT_PFHT900_v*',
),
hltResults = cms.InputTag( "TriggerResults", "", "HLT" ),
l1tResults = cms.InputTag( "gtDigis" ),
l1tIgnoreMask = cms.bool( False ),
l1techIgnorePrescales = cms.bool( False ),
daqPartitions = cms.uint32( 1 ),
throw = cms.bool( False )
)
process.jetFilter = cms.EDFilter("JetFilter",
srcJets = cms.InputTag("ak4PFJetsCHS"),
# srcJets = cms.InputTag("patJets"),
# additionalCut = cms.string(""),
additionalCut = cms.string("abs(eta) < 2.5 && pt > 50.0"),
jetCuts = cms.VPSet(
cms.PSet(
minPt = cms.double(400.0),
maxEta = cms.double(2.5),
stringCut = cms.string(""),
),
cms.PSet(
minPt = cms.double(200.0),
maxEta = cms.double(2.5),
stringCut = cms.string(""),
),
cms.PSet(
minPt = cms.double(125.0),
maxEta = cms.double(2.5),
stringCut = cms.string(""),
),
cms.PSet(
minPt = cms.double(50.0),
maxEta = cms.double(2.5),
stringCut = cms.string(""),
),
)
)
process.eventCountPreTrigger = cms.EDAnalyzer('EventCounter')
process.eventCountPreFilter = cms.EDAnalyzer('EventCounter')
process.eventCountPostFilter = cms.EDAnalyzer('EventCounter')
if isData:
return cms.Sequence(process.eventCountPreTrigger * process.triggerSelection * process.eventCountPreFilter * process.jetFilter * process.eventCountPostFilter)
else:
return cms.Sequence(process.eventCountPreTrigger * cms.ignore(process.triggerSelection) * process.eventCountPreFilter * process.jetFilter * process.eventCountPostFilter)
def testIgnoreFiltersOnPath(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("Test")
process.f1 = cms.EDFilter("F1")
process.f2 = cms.EDFilter("F2")
process.f3 = cms.EDFilter("F3")
process.s = cms.Sequence(process.f3)
process.p = cms.Path(process.f1 + cms.ignore(process.f2) +
process.s)
ignoreAllFiltersOnPath(process.p)
self.assertEqual(
process.p.dumpPython(None),
'cms.Path(cms.ignore(process.f1)+cms.ignore(process.f2)+cms.ignore(process.f3))\n'
)
def testIgnoreFiltersOnPath(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("Test")
process.f1 = cms.EDFilter("F1")
process.f2 = cms.EDFilter("F2")
process.f3 = cms.EDFilter("F3")
process.f4 = cms.EDFilter("F4")
process.f5 = cms.EDFilter("F5")
process.f6 = cms.EDFilter("F6")
process.t1 = cms.Task(process.f5)
process.t2 = cms.Task(process.f6)
process.s = cms.Sequence(process.f4, process.t1)
process.p = cms.Path(process.f1+cms.ignore(process.f2)+process.f3+process.s, process.t2)
ignoreAllFiltersOnPath(process.p)
self.assertEqual(process.p.dumpPython(),'cms.Path(cms.ignore(process.f1)+cms.ignore(process.f2)+cms.ignore(process.f3)+cms.ignore(process.f4), process.t1, process.t2)\n')
def testIgnoreFiltersOnPath(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("Test")
process.f1 = cms.EDFilter("F1")
process.f2 = cms.EDFilter("F2")
process.f3 = cms.EDFilter("F3")
process.f4 = cms.EDFilter("F4")
process.f5 = cms.EDFilter("F5")
process.f6 = cms.EDFilter("F6")
process.t1 = cms.Task(process.f5)
process.t2 = cms.Task(process.f6)
process.s = cms.Sequence(process.f4, process.t1)
process.p = cms.Path(process.f1+cms.ignore(process.f2)+process.f3+process.s, process.t2)
ignoreAllFiltersOnPath(process.p)
self.assertEqual(process.p.dumpPython(None),'cms.Path(cms.ignore(process.f1)+cms.ignore(process.f2)+cms.ignore(process.f3)+cms.ignore(process.f4), process.t1, process.t2)\n')
import FWCore.ParameterSet.Config as cms
GenSelector = cms.EDFilter("GenSelector",#creates reco::CandidateRefVector containing refs to selected genParticles
candCollection = cms.InputTag("genParticles"),#genParticleCandidates #needs same collection as MCTruthDeltaRMatcherNew
decayType = cms.untracked.string(''),#tauGun,Ztautau,...
motherPdgID = cms.untracked.int32(0)#search for taus within a decay of a mother with given pdgID, 0 ignores the mother
)
printTree = cms.EDAnalyzer("ParticleListDrawer",
maxEventsToPrint = cms.untracked.int32(0),
printVertex = cms.untracked.bool(True),
src = cms.InputTag("genParticles")
)
printSelectedTree = cms.EDAnalyzer("ParticleListDrawer",
maxEventsToPrint = cms.untracked.int32(0),
printVertex = cms.untracked.bool(True),
src = cms.InputTag("GenSelector","genSignalDecay")
)
generatorSequence = cms.Sequence(printTree+cms.ignore(GenSelector))
#generatorSequence = cms.Sequence(cms.ignore(GenSelector)*printSelectedTree)#+ as printTree is not required
#generatorSequence = cms.Sequence(cms.ignore(GenSelector))
moduleName = moduleName.lstrip("cms.ignore(process.")
moduleName = moduleName.rstrip(")")
module = getattr(process, moduleName)
path.replace(obj, module)
if type(obj).__name__ == "Sequence":
rmOperatorsFromFilters(process, obj)
if runOpen:
for pathName in process.pathNames().split():
path = getattr(process, pathName)
rmOperatorsFromFilters(process, path)
for filterName in path.moduleNames():
filt = getattr(process, filterName)
if type(filt).__name__ == "EDFilter":
path.replace(filt, cms.ignore(filt))
def cleanList(input, blacklist):
output = set()
for x in input:
if x not in blacklist:
output.add(x)
#print output
return output
productsToKeep = set()
for pathName in process.pathNames().split():
path = getattr(process, pathName)
for filterName in path.moduleNames():
hltIter4V = hltMultiTrackValidator.clone()
hltIter4V.label = cms.VInputTag(
cms.InputTag("hltIter4PFlowTrackSelectionHighPurity"))
hltIter4V.trackCollectionForDrCalculation = cms.InputTag(
"hltIter4PFlowTrackSelectionHighPurity")
hltIter4MergedV = hltMultiTrackValidator.clone()
hltIter4MergedV.label = cms.VInputTag(cms.InputTag("hltIter4Merged"))
hltIter4MergedV.trackCollectionForDrCalculation = cms.InputTag(
"hltIter4Merged")
from Validation.RecoTrack.cutsTPEffic_cfi import *
from Validation.RecoTrack.cutsTPFake_cfi import *
from SimGeneral.TrackingAnalysis.simHitTPAssociation_cfi import *
hltMultiTrackValidation = cms.Sequence(
# simHitTPAssocProducer
# +
hltTPClusterProducer
# + tpToHLTtracksAssociationSequence # not needed because MTV is configured to use the associators in itself, instead we need the hltTrackAssociatorByHits
+ hltTrackAssociatorByHits + cms.ignore(cutsTPEffic) +
cms.ignore(cutsTPFake) + hltPixelTracksV + hltIter0V + hltIter1V +
hltIter1MergedV + hltIter2V + hltIter2MergedV
# + hltIter3V
# + hltIter3MergedV
# + hltIter4V
# + hltIter4MergedV
)
# the track selectors
tracksValidationSelectors = cms.Sequence(tracksValidationSelectorsByAlgo +
tracksValidationSelectorsByAlgoHp +
cutsRecoTracksBtvLike +
ak4JetTracksAssociatorExplicitAll +
cutsRecoTracksAK4PFJets)
tracksValidationTruth = cms.Sequence(tpClusterProducer +
quickTrackAssociatorByHits +
trackingParticleRecoTrackAsssociation +
VertexAssociatorByPositionAndTracks)
eras.fastSim.toModify(tracksValidationTruth,
lambda x: x.remove(tpClusterProducer))
tracksValidationTruthSignal = cms.Sequence(
cms.ignore(trackingParticlesSignal) + tpClusterProducerSignal +
quickTrackAssociatorByHitsSignal +
trackingParticleRecoTrackAsssociationSignal)
eras.fastSim.toModify(tracksValidationTruthSignal,
lambda x: x.remove(tpClusterProducerSignal))
tracksValidationTruthConversion = cms.Sequence(
trackingParticlesConversion + tpClusterProducerConversion +
quickTrackAssociatorByHitsConversion)
tracksPreValidation = cms.Sequence(tracksValidationSelectors +
tracksValidationSelectorsFromPV +
tracksValidationTruth +
tracksValidationTruthSignal +
tracksValidationTruthConversion)
eras.fastSim.toModify(tracksPreValidation,
srcHardScatterVertex = cms.InputTag('selectedPrimaryVertexHighestPtTrackSumForPFMEtCorrType0'),
correction = cms.PSet(
formula = cms.string("-([0] + [1]*x)*(1.0 + TMath::Erf(-[2]*TMath::Power(x, [3])))"),
par0 = cms.double(0.),
par1 = cms.double(-0.703151),
par2 = cms.double(0.0303531),
par3 = cms.double(0.909209)
),
minDz = cms.double(0.2) # [cm], minimum distance required between pile-up vertices and "hard scatter" vertex
)
#--------------------------------------------------------------------------------
type0PFMEtCorrectionPFCandToVertexAssociation = cms.Sequence(
selectedVerticesForPFMEtCorrType0
* selectedPrimaryVertexHighestPtTrackSumForPFMEtCorrType0
* particleFlowDisplacedVertex
* pfCandidateToVertexAssociation
)
type0PFMEtCorrectionPFCandToVertexAssociationForValidation = cms.Sequence(
cms.ignore(selectedVerticesForPFMEtCorrType0)
* cms.ignore(selectedPrimaryVertexHighestPtTrackSumForPFMEtCorrType0)
* particleFlowDisplacedVertex
* pfCandidateToVertexAssociation
)
type0PFMEtCorrection = cms.Sequence(
type0PFMEtCorrectionPFCandToVertexAssociation
* pfMETcorrType0
)
tauIDSeq = cms.Sequence()
if prepareEvtDisplay:
process.debugOutput = cms.OutputModule("PoolOutputModule",
outputCommands = cms.untracked.vstring('keep *'),
fileName = cms.untracked.string('debugOutput.root'),
)
process.out_step = cms.EndPath(process.debugOutput)
#ignore filter
process.ignorePath = cms.Path(
process.generatorSequence
*tauIDSeq
*jetCorrectionProducer
*process.METCorrections
*cms.ignore(process.PrimVtxSelector)
#*cms.ignore(process.HLTSelector)
*cms.ignore(process.InputTrackSelector)
*process.ignoreThreeProngInputSelector
*cms.ignore(process.KinematicTauProducer)
*process.matchingSeq
#*process.MultiCandidateSelector
*process.FinalTreeFiller
)
#cumulative
process.cumulativePath = cms.Path(
process.cleaning
*process.triggerSelection
*process.generatorSequence
*tauIDSeq
*jetCorrectionProducer
#"keep *_*_puBX_*",
#"keep *_*_puNInt_*",
#"keep *_eventInfo_*_*",
#"keep *_eventUserData_*_*",
)
)
if options.runMuon:
process.out.outputCommands += [
"drop *_electrons_*_*",# sometimes gives LogicError
"drop *_anaelel_*_*",
"drop *_*_goodElectronsIdxs_*",
"drop *_*_goodElectrons_*",
]
process.p = cms.Path(
process.allEvents
*cms.ignore(process.anaelel)
*process.anamumu
*process.GenInfo
*process.selectedEvents
)
else:
process.out.outputCommands += [
"drop *_muons_*_*",
"drop *_anamumu_*_*",
"drop *_*_goodMuonsIdxs_*",
"drop *_*_goodMuons_*",
]
process.p = cms.Path(
process.allEvents
*cms.ignore(process.anamumu)
*process.anaelel
import FWCore.ParameterSet.Config as cms
from RecoParticleFlow.PFProducer.pfGsfElectronCiCSelector_cfi import *
pfGsfElectronCiCSelectionSequence = cms.Sequence(
cms.ignore(electronsWithPresel) + cms.ignore(electronsCiCLoose))
# replace 'myfile.root' with the source file you want to use
fileNames = cms.untracked.vstring(
# 'file:myfile.root'
'file:/tmp/adamwo/Hermine/src/JpsiMM_cfi_py_GEN_SIM.root'
)
)
process.options = cms.untracked.PSet(
wantSummary = cms.untracked.bool(True)
)
process.demo = cms.EDFilter('MuonSimHitCountFilter',
simTracks = cms.InputTag("g4SimHits"),
simHits = cms.VInputTag(cms.InputTag("g4SimHits","MuonCSCHits"),
cms.InputTag("g4SimHits","MuonDTHits")),
minHitsChamber = cms.vint32(2,2),
minHitsSubDet = cms.vint32(2,2),
minHitsTotal = cms.int32(-1),
particleTypes = cms.vint32(-13,13),
processTypes = cms.vint32()
)
process.p = cms.Path(cms.ignore(process.demo))
process.out = cms.OutputModule("PoolOutputModule",
fileName = cms.untracked.string('test.root')
)
process.outPath = cms.EndPath(process.out)
def addWJetSkim(process, isData=False):
print "Adding WJet Skim step."
print "triggerSelection should be verified for new datasets."
print "electronID should be modified for each global tag."
process.triggerSelection = cms.EDFilter( "TriggerResultsFilter",
triggerConditions = cms.vstring(
# Data: Run2015*
'HLT_Ele27_eta2p1_WPLoose_Gsf_v*',
'HLT_Ele27_eta2p1_WPTight_Gsf_v*',
'HLT_IsoMu24_eta2p1_v*',
# MC: RunIISpring15DR74
'HLT_Ele27_eta2p1_WP75_Gsf_v*', # Off at 1.4e34
'HLT_Ele32_eta2p1_WP75_Gsf_v*',
# 'HLT_IsoMu24_eta2p1_v*', # same in data
# 'HLT_IsoMu27_v*', # Good for data and MC, turn off for now for consistency
# Exists in MC
# 'HLT_Ele22_eta2p1_WP75_Gsf_v*',
# 'HLT_IsoMu17_v*',
# Exists in data, unprescaled
# 'HLT_IsoMu20_v*',
#
# 'HLT_IsoMu22_v*',
# 'HLT_IsoMu20_eta2p1_v*',
),
hltResults = cms.InputTag( "TriggerResults", "", "HLT" ),
l1tResults = cms.InputTag( "gtDigis" ),
l1tIgnoreMask = cms.bool( False ),
l1techIgnorePrescales = cms.bool( False ),
daqPartitions = cms.uint32( 1 ),
throw = cms.bool( False )
)
process.wJetFilter = cms.EDFilter("WJetFilter",
isData = cms.bool( False ),
srcMuons = cms.InputTag("slimmedMuons"),
srcElectrons = cms.InputTag("slimmedElectrons"),
srcJets = cms.InputTag("slimmedJets"),
srcMET = cms.InputTag("slimmedMETs"),
minPtMuon = cms.double(20.0),
minPtElectron = cms.double(20.0),
minPtMET = cms.double(20.0),
minMt = cms.double(50.0),
maxMt = cms.double(100.0),
minDeltaR = cms.double(0.4),
maxDeltaPhi = cms.double(0.4), # Doesn't do anything
minPtSelectedJet = cms.double(20.0),
maxPtAdditionalJets = cms.double(20.0), # Doesn't do anything
electronID = cms.string('cutBasedElectronID-Spring15-25ns-V1-standalone-medium'),
# electronID = cms.string('cutBasedElectronID-CSA14-50ns-V1-standalone-medium'),
)
if isData: process.wJetFilter.isData = cms.bool(True)
process.eventCountPreTrigger = cms.EDAnalyzer('EventCounter')
process.eventCountPreFilter = cms.EDAnalyzer('EventCounter')
process.eventCountPostFilter = cms.EDAnalyzer('EventCounter')
############################################################
# Recreate miniAOD
############################################################
if isData:
# customisation of the process.
process.load('Configuration.StandardSequences.PAT_cff')
# Automatic addition of the customisation function from PhysicsTools.PatAlgos.slimming.miniAOD_tools
from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllData
#call to customisation function miniAOD_customizeAllData imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools
process = miniAOD_customizeAllData(process)
else:
# customisation of the process.
process.load('Configuration.StandardSequences.PATMC_cff')
# Automatic addition of the customisation function from PhysicsTools.PatAlgos.slimming.miniAOD_tools
from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC
#call to customisation function miniAOD_customizeAllMC imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools
process = miniAOD_customizeAllMC(process)
############################################################
# Ignore trigger selection if MC
if isData:
return cms.Sequence(process.eventCountPreTrigger * (process.triggerSelection) * process.eventCountPreFilter * process.wJetFilter * process.eventCountPostFilter)
else:
return cms.Sequence(process.eventCountPreTrigger * cms.ignore(process.triggerSelection) * process.eventCountPreFilter * process.wJetFilter * process.eventCountPostFilter)
process.looseSoftElectronByIP3dCaloBJetTags +
process.standardSoftElectronByIP3dPFBJetTags +
process.looseSoftElectronByIP3dPFBJetTags
)
process.bTagValidation = cms.Sequence(
process.caloBTagAnalysis +
process.pfBTagAnalysis
)
process.plots = cms.Path(
process.bit40 +
process.bptxAnd +
process.physDecl +
process.noscraping +
process.oneGoodVertexFilter +
cms.ignore(process.PFJetsFilter) +
cms.ignore(process.CaloJetsFilter) +
process.trackAssociation *
process.ipTagInfos *
process.svTagInfos *
process.ipTaggers *
process.svTaggers *
process.slTagInfos *
process.slTaggers *
process.bTagValidation *
process.MEtoEDMConverter
)
process.outpath = cms.EndPath(process.EDM)
import FWCore.ParameterSet.Config as cms
from Validation.EventGenerator.MBUEandQCDValidation_cfi import *
from RecoJets.Configuration.GenJetParticles_cff import *
from RecoJets.Configuration.RecoGenJets_cff import *
chargedParticles = cms.EDFilter("GenParticleSelector",
filter = cms.bool(False),
src = cms.InputTag("genParticles"),
cut = cms.string('charge != 0 & pt > 0.05 & status = 1 & eta < 2.5 & eta > -2.5')
)
chargedak4GenJets = ak4GenJets.clone( src = cms.InputTag("chargedParticles") )
mbueAndqcd_seq = cms.Sequence(cms.ignore(chargedParticles)*chargedak4GenJets*mbueAndqcdValidation)
JetCorrections=cms.InputTag("dqmAk4CaloL2L3Corrector"))
jetDQMAnalyzerAk4PFUncleanedMC = jetDQMAnalyzerAk4PFUncleaned.clone(
JetCorrections=cms.InputTag("dqmAk4PFL1FastL2L3Corrector"))
jetDQMAnalyzerAk4PFCleanedMC = jetDQMAnalyzerAk4PFCleaned.clone(
JetCorrections=cms.InputTag("dqmAk4PFL1FastL2L3Corrector"))
jetDQMAnalyzerAk4PFCHSCleanedMC = jetDQMAnalyzerAk4PFCHSCleaned.clone(
JetCorrections=cms.InputTag("dqmAk4PFCHSL1FastL2L3Corrector"))
caloMetDQMAnalyzerMC = caloMetDQMAnalyzer.clone(
JetCorrections=cms.InputTag("dqmAk4CaloL2L3Corrector"))
pfMetDQMAnalyzerMC = pfMetDQMAnalyzer.clone(
JetCorrections=cms.InputTag("dqmAk4PFL1FastL2L3Corrector"))
pfMetT1DQMAnalyzerMC = pfMetT1DQMAnalyzer.clone(
JetCorrections=cms.InputTag("dqmAk4PFCHSL1FastL2L3Corrector"))
jetMETDQMOfflineSource = cms.Sequence(
cms.ignore(goodOfflinePrimaryVerticesDQM) * AnalyzeSUSYDQM * QGTagger *
pileupJetIdCalculatorCHSDQM * pileupJetIdEvaluatorCHSDQM *
pileupJetIdCalculatorDQM * pileupJetIdEvaluatorDQM * jetPreDQMSeq *
dqmAk4CaloL2L3CorrectorChain * dqmAk4PFL1FastL2L3CorrectorChain *
dqmAk4PFCHSL1FastL2L3CorrectorChain * dqmCorrPfMetType1 * pfMETT1 *
jetDQMAnalyzerAk4CaloCleanedMC * jetDQMAnalyzerAk4PFUncleanedMC *
jetDQMAnalyzerAk4PFCleanedMC * jetDQMAnalyzerAk4PFCHSCleanedMC *
HBHENoiseFilterResultProducer * caloMetDQMAnalyzerMC * pfMetDQMAnalyzerMC *
pfMetT1DQMAnalyzerMC)
jetMETDQMOfflineRedoProductsMiniAOD = cms.Sequence(
goodOfflinePrimaryVerticesDQMforMiniAOD)
jetMETDQMOfflineSourceMiniAOD = cms.Sequence(jetDQMAnalyzerSequenceMiniAOD *
METDQMAnalyzerSequenceMiniAOD)
cut=cms.string(
"isValid & ndof > 4 & tracksSize > 0 & abs(z) <= 24 & abs(position.Rho) <= 2."
),
filter=cms.bool(False))
selectedOfflinePrimaryVerticesWithBS = selectedOfflinePrimaryVertices.clone()
selectedOfflinePrimaryVerticesWithBS.src = cms.InputTag(
'offlinePrimaryVerticesWithBS')
selectedPixelVertices = selectedOfflinePrimaryVertices.clone()
selectedPixelVertices.src = cms.InputTag('pixelVertices')
vertexAnalysis = cms.EDAnalyzer(
"PrimaryVertexAnalyzer4PUSlimmed",
simG4=cms.InputTag("g4SimHits"),
use_TP_associator=cms.untracked.bool(False),
verbose=cms.untracked.bool(False),
sigma_z_match=cms.untracked.double(3.0),
root_folder=cms.untracked.string("Validation/Vertices"),
recoTrackProducer=cms.untracked.string("generalTracks"),
vertexRecoCollections=cms.VInputTag(
"offlinePrimaryVertices", "offlinePrimaryVerticesWithBS",
"pixelVertices", "selectedOfflinePrimaryVertices",
"selectedOfflinePrimaryVerticesWithBS", "selectedPixelVertices"),
)
vertexAnalysisSequence = cms.Sequence(
cms.ignore(selectedOfflinePrimaryVertices) *
cms.ignore(selectedOfflinePrimaryVerticesWithBS) *
cms.ignore(selectedPixelVertices) * vertexAnalysis)
# HLT_RsqMR300_Rsq0p09_MR200_4jet_v* tight
RsqMR300_Rsq0p09_MR200_4jet_Tight_RazorMonitoring = hltRazorMonitoring.clone(
FolderName='HLT/SUSY/RsqMR300_Rsq0p09_MR200_4jet_Tight/',
numGenericTriggerEventPSet=dict(
hltPaths=["HLT_RsqMR300_Rsq0p09_MR200_4jet_v*"]),
jetSelection="pt>120")
# HLT_RsqMR320_Rsq0p09_MR200_4jet_v*
RsqMR320_Rsq0p09_MR200_4jet_RazorMonitoring = hltRazorMonitoring.clone(
FolderName='HLT/SUSY/RsqMR320_Rsq0p09_MR200_4jet/',
numGenericTriggerEventPSet=dict(
hltPaths=["HLT_RsqMR320_Rsq0p09_MR200_4jet_v*"]))
# HLT_RsqMR320_Rsq0p09_MR200_4jet_v* tight
RsqMR320_Rsq0p09_MR200_4jet_Tight_RazorMonitoring = hltRazorMonitoring.clone(
FolderName='HLT/SUSY/RsqMR320_Rsq0p09_MR200_4jet_Tight/',
numGenericTriggerEventPSet=dict(
hltPaths=["HLT_RsqMR320_Rsq0p09_MR200_4jet_v*"]),
jetSelection="pt>120")
susyHLTRazorMonitoring = cms.Sequence(
cms.ignore(hemispheresDQM) + #for razor triggers
cms.ignore(caloHemispheresDQM) + #for razor triggers
Rsq0p35_RazorMonitoring + Rsq0p35_Tight_RazorMonitoring +
Rsq0p40_RazorMonitoring + Rsq0p40_Tight_RazorMonitoring +
RsqMR300_Rsq0p09_MR200_RazorMonitoring +
RsqMR300_Rsq0p09_MR200_Tight_RazorMonitoring +
RsqMR320_Rsq0p09_MR200_RazorMonitoring +
RsqMR320_Rsq0p09_MR200_Tight_RazorMonitoring +
RsqMR300_Rsq0p09_MR200_4jet_RazorMonitoring +
RsqMR300_Rsq0p09_MR200_4jet_Tight_RazorMonitoring +
RsqMR320_Rsq0p09_MR200_4jet_RazorMonitoring +
RsqMR320_Rsq0p09_MR200_4jet_Tight_RazorMonitoring)
tracksValidationTruth = cms.Sequence(
tpClusterProducer +
quickTrackAssociatorByHits +
trackingParticleRecoTrackAsssociation +
VertexAssociatorByPositionAndTracks +
trackingParticleNumberOfLayersProducer
)
fastSim.toModify(tracksValidationTruth, lambda x: x.remove(tpClusterProducer))
tracksPreValidation = cms.Sequence(
tracksValidationSelectors +
tracksValidationSelectorsPt09 +
tracksValidationSelectorsFromPV +
tracksValidationSelectorsFromPVPt09 +
tracksValidationTruth +
cms.ignore(trackingParticlesSignal) +
cms.ignore(trackingParticlesElectron) +
trackingParticlesConversion
)
fastSim.toReplaceWith(tracksPreValidation, tracksPreValidation.copyAndExclude([
trackingParticlesElectron,
trackingParticlesConversion,
]))
tracksValidation = cms.Sequence(
tracksPreValidation +
trackValidator +
trackValidatorTPPtLess09 +
trackValidatorFromPV +
trackValidatorFromPVAllTP +
trackValidatorAllTPEffic +
)
zttModifier = ApplyFunctionToSequence(lambda m: setBinning(m,binning))
proc.TauValNumeratorAndDenominatorRealElectronsData.visit(zttModifier)
#-----------------------------------------
#Sets the correct naming to efficiency histograms
proc.efficienciesRealElectronsData.plots = Utils.SetPlotSequence(proc.TauValNumeratorAndDenominatorRealElectronsData)
#checks what's new in the process (the cloned sequences and modules in them)
newProcAttributes = filter( lambda x: (x not in procAttributes) and (x.find('RealElectronsData') != -1), dir(proc) )
#spawns a local variable with the same name as the proc attribute, needed for future process.load
for newAttr in newProcAttributes:
locals()[newAttr] = getattr(proc,newAttr)
produceDenominatorRealElectronsData = cms.Sequence( cms.ignore(ElPrimaryVertexFilter) * ElBestPV *
( (cms.ignore(selectedElectrons) * ElectronsFromPV * cms.ignore(idElectrons) * cms.ignore(trackElectrons) * cms.ignore(isolatedElectrons)) +
(cms.ignore(ElGoodTracks) * ElIsoTracks * ElTrackFromPV * ElTrackCands) ) *
ZeeCandElectronTrack *
BestZee *
ElZLegs
)
produceDenominator = cms.Sequence(produceDenominatorRealElectronsData)
runTauValidationBatchMode = cms.Sequence(
produceDenominatorRealElectronsData
+TauValNumeratorAndDenominatorRealElectronsData
)
runTauValidation = cms.Sequence(
import FWCore.ParameterSet.Config as cms
from RecoParticleFlow.PostProcessing.selectGoodPFEvents_cff import *
from RecoParticleFlow.PostProcessing.selectEventsWithSmallDeltaPtMuons_cff import *
from UserCode.EcalDeadCellEventFilter.EcalDeadCellEventFilter_cff import *
from PhysicsTools.EcalAnomalousEventFilter.ecalanomalouseventfilter_cfi import *
# to study the filters
eventCleaningFiltersIgnore = cms.Sequence(
# Muon Filters in RA2
cms.ignore( greedyMuons ) +
cms.ignore( inconsistentMuons ) +
# Delta pt filter (dropped from RA2 )
largeDeltaPtMuons +
cms.ignore( filterLargeDeltaPtMuons ) +
# BE filter
cms.ignore( EcalAnomalousEventFilter )
)
# main filtering sequence for analysis
eventCleaningFilters = cms.Sequence(
# greedy and inconsistent muons
selectGoodPFEventsSequence +
# BE filter
EcalAnomalousEventFilter
)
# for the Data, we add TP filtering
highPurityTracks.cut = cms.string("quality('highPurity')")
hltMerged2highPurity = trackToTrackComparisonHists.clone()
hltMerged2highPurity.monitoredTrack = cms.InputTag("hltMergedTracks")
hltMerged2highPurity.referenceTrack = cms.InputTag("highPurityTracks")
hltMerged2highPurity.monitoredBeamSpot = cms.InputTag("hltOnlineBeamSpot")
hltMerged2highPurity.referenceBeamSpot = cms.InputTag("offlineBeamSpot")
hltMerged2highPurity.topDirName = cms.string(
"HLT/Tracking/ValidationWRTOffline/hltMergedWrtHighPurity")
hltMerged2highPurity.referencePrimaryVertices = cms.InputTag(
"offlinePrimaryVertices")
hltMerged2highPurity.monitoredPrimaryVertices = cms.InputTag(
"hltVerticesPFSelector")
hltMerged2highPurityPV = trackToTrackComparisonHists.clone()
hltMerged2highPurityPV.dzWRTPvCut = cms.double(0.1)
hltMerged2highPurityPV.monitoredTrack = cms.InputTag("hltMergedTracks")
hltMerged2highPurityPV.referenceTrack = cms.InputTag("highPurityTracks")
hltMerged2highPurityPV.monitoredBeamSpot = cms.InputTag("hltOnlineBeamSpot")
hltMerged2highPurityPV.referenceBeamSpot = cms.InputTag("offlineBeamSpot")
hltMerged2highPurityPV.topDirName = cms.string(
"HLT/Tracking/ValidationWRTOffline/hltMergedWrtHighPurityPV")
hltMerged2highPurityPV.referencePrimaryVertices = cms.InputTag(
"offlinePrimaryVertices")
hltMerged2highPurityPV.monitoredPrimaryVertices = cms.InputTag(
"hltVerticesPFSelector")
hltToOfflineTrackValidatorSequence = cms.Sequence(
cms.ignore(highPurityTracks) + hltMerged2highPurity +
hltMerged2highPurityPV)
import FWCore.ParameterSet.Config as cms
#build the hemispheres from our jets
scoutingRHemisphere = cms.EDFilter("HLTRHemisphere",
acceptNJ = cms.bool(True),
maxEta = cms.double(3.0),
inputTag = cms.InputTag("hltCaloJetIDPassed"),
maxMuonEta = cms.double(2.1),
muonTag = cms.InputTag(""),
minJetPt = cms.double(30.0),
doMuonCorrection = cms.bool(False),
maxNJ = cms.int32(14)
)
scoutingRazorVariables = cms.EDProducer("RazorVarProducer",
inputTag = cms.InputTag("scoutingRHemisphere"),
inputMetTag = cms.InputTag("hltMetClean"),
)
scoutingRazorVarAnalyzer = cms.EDAnalyzer("RazorVarAnalyzer",
modulePath=cms.untracked.string("Razor"),
razorVarCollectionName=cms.untracked.InputTag("scoutingRazorVariables")
)
#this file contains the sequence for data scouting using the Razor analysis
scoutingRazorDQMSequence = cms.Sequence(cms.ignore(scoutingRHemisphere)*
scoutingRazorVariables*
scoutingRazorVarAnalyzer
)
MonitorTrackMuonsInnerTrack.doSeedParameterHistos = False MonitorTrackMuonsInnerTrack.doProfilesVsLS = False MonitorTrackMuonsInnerTrack.doAllPlots = False MonitorTrackMuonsInnerTrack.doGeneralPropertiesPlots = True MonitorTrackMuonsInnerTrack.doHitPropertiesPlots = True MonitorTrackMuonsInnerTrack.doTrackerSpecific = True MonitorTrackMuonsInnerTrack.doDCAPlots = True MonitorTrackMuonsInnerTrack.doDCAwrtPVPlots = True MonitorTrackMuonsInnerTrack.doDCAwrt000Plots = False MonitorTrackMuonsInnerTrack.doSIPPlots = True MonitorTrackMuonsInnerTrack.doEffFromHitPatternVsPU = True MonitorTrackMuonsInnerTrack.doEffFromHitPatternVsBX = False MonitorTrackMuonsInnerTrack.TkSizeBin = 10 MonitorTrackMuonsInnerTrack.TkSizeMax = 10. MonitorTrackMuonsInnerTrack.phiErrMax = 0.001 MonitorTrackMuonsInnerTrack.etaErrMax = 0.001 MonitorTrackMuonsInnerTrack.PVBin = 40 MonitorTrackMuonsInnerTrack.PVMin = -0.5 MonitorTrackMuonsInnerTrack.PVMax = 79.5 ## it might need to be adjust if CMS asks to have lumi levelling at lower values from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase1Pixel.toModify(MonitorTrackMuonsInnerTrack, EtaBin=31, EtaMin=-3., EtaMax=3.) phase2_tracker.toModify(MonitorTrackMuonsInnerTrack, EtaBin=46, EtaMin=-4.5, EtaMax=4.5) phase2_tracker.toModify(MonitorTrackMuonsInnerTrack, PVBin=125, PVMin=-0.5, PVMax=249.5) #MonitorTrackINNMuons = cms.Sequence(muonInnerTrack+MonitorTrackMuonsInnerTrack) MonitorTrackINNMuons = cms.Sequence(cms.ignore(muonsPt10)+muonInnerTrack+MonitorTrackMuonsInnerTrack)
#####################################################
process.p += process.mypf2pat
#process.p += process.mymet
process.p += process.pfMetSig
process.p += process.puJetIdSqeuenceChs
process.p += process.kt6PFJetsForIsolation2011
process.p += process.pfMEtSysShiftCorrSequence
process.p += process.type0PFMEtCorrection
process.p += process.producePFMETCorrections
process.p += process.patPFMETsTypeIcorrected
process.p += process.pfType1Type0PFCandidateCorrectedMet
process.p += process.patPFMETsTypeIType0PFCandcorrected
process.p += process.pfType1XYCorrectedMet
process.p += process.patPFMETsTypeIXYcorrected
if usePdfWeights:
process.p += process.pdfWeights
process.trackingfailturefilter = cms.Path(process.trackingFailureFilter)
process.outpath = cms.EndPath(cms.ignore(process.configurableAnalysis))
#process.outpath = cms.EndPath(process.out) #Output the SUSYPAT.root file
#-- Dump config ------------------------------------------------------------
file = open('SusyPAT_cfg.py','w')
file.write(str(process.dumpPython()))
file.close()
bTagHLTTrackMonitoring_SixJetCalo.topDirName = cms.string(
"HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94PF")
bTagHLTTrackMonitoring_SixJetCalo.genericTriggerEventPSet.hltPaths = cms.vstring(
"HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94_v*")
bTagHLTTrackMonitoring_EmuPF = bTagHLTTrackMonitoring_EmuCalo.clone()
bTagHLTTrackMonitoring_EmuPF.monitoredTrack = cms.InputTag("hltMergedTracks")
bTagHLTTrackMonitoring_EmuPF.monitoredPrimaryVertices = cms.InputTag(
"hltVerticesPFSelector")
bTagHLTTrackMonitoring_EmuPF.topDirName = cms.string(
"HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5PF"
)
bTagHLTTrackMonitoring_EmuPF.genericTriggerEventPSet.hltPaths = cms.vstring(
"HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5*"
)
bTagHLTTrackMonitoring_SixJetPF = bTagHLTTrackMonitoring_EmuPF.clone()
bTagHLTTrackMonitoring_SixJetPF.monitoredTrack = cms.InputTag(
"hltMergedTracks")
bTagHLTTrackMonitoring_SixJetPF.monitoredPrimaryVertices = cms.InputTag(
"hltVerticesPFSelector")
bTagHLTTrackMonitoring_SixJetPF.topDirName = cms.string(
"HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94PF")
bTagHLTTrackMonitoring_SixJetPF.genericTriggerEventPSet.hltPaths = cms.vstring(
"HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94_v*")
bTagHLTTrackMonitoringSequence = cms.Sequence(
cms.ignore(referenceTracksForHLTBTag) + bTagHLTTrackMonitoring_EmuCalo +
bTagHLTTrackMonitoring_SixJetCalo + bTagHLTTrackMonitoring_EmuPF +
bTagHLTTrackMonitoring_SixJetPF)
from RecoLuminosity.LumiProducer.lumiProducer_cff import *
# import v0 monitoring
from DQM.TrackingMonitor.V0Monitor_cff import *
# better clone for now because goodOfflinePrimaryVertices is used also
# within the reco sequence, and without cloning framework will throw
# "unrunnable schedule" exception for workflows without --runUnscheduled
from CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi import goodOfflinePrimaryVertices
trackingDQMgoodOfflinePrimaryVertices = goodOfflinePrimaryVertices.clone()
# import PV resolution
from DQM.TrackingMonitor.primaryVertexResolution_cfi import *
# Sequence
TrackingDQMSourceTier0 = cms.Sequence(cms.ignore(trackingDQMgoodOfflinePrimaryVertices))
# dEdx monitoring
TrackingDQMSourceTier0 += dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon
# # temporary patch in order to have BXlumi
# * lumiProducer
# track collections
for tracks in selectedTracks :
if tracks != 'generalTracks':
TrackingDQMSourceTier0 += cms.ignore(sequenceName[tracks])
label = 'TrackerCollisionSelectedTrackMonCommon' + str(tracks)
TrackingDQMSourceTier0 += cms.ignore(locals()[label])
# seeding monitoring
for _eraName, _postfix, _era in _cfg.allEras():
mvaSel = _utils.getMVASelectors(_postfix)
_seq = cms.Sequence()
for step in locals()["selectedIterTrackingStep"+_postfix]:
jetCoreRegionalStep.mva.maxDz = [0.5, 0.35, 0.2]
jetCoreRegionalStep.mva.maxDr = [0.3, 0.2, 0.1]
jetCoreRegionalStep.vertices = 'firstStepGoodPrimaryVertices'
from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *
trackingPhase1.toReplaceWith(
jetCoreRegionalStep,
TrackMVAClassifierPrompt.clone(
src='jetCoreRegionalStepTracks',
mva=dict(GBRForestLabel='MVASelectorJetCoreRegionalStep_Phase1'),
qualityCuts=[-0.2, 0.0, 0.4],
))
trackingPhase1QuadProp.toReplaceWith(
jetCoreRegionalStep,
TrackMVAClassifierPrompt.clone(
src='jetCoreRegionalStepTracks',
mva=dict(GBRForestLabel='MVASelectorJetCoreRegionalStep_Phase1'),
qualityCuts=[-0.2, 0.0, 0.4],
))
# Final sequence
JetCoreRegionalStep = cms.Sequence(
cms.ignore(jetsForCoreTracking) *
cms.ignore(firstStepGoodPrimaryVertices) *
#jetCoreRegionalStepClusters*
jetCoreRegionalStepSeedLayers * jetCoreRegionalStepTrackingRegions *
jetCoreRegionalStepHitDoublets * jetCoreRegionalStepSeeds *
jetCoreRegionalStepTrackCandidates * jetCoreRegionalStepTracks *
# jetCoreRegionalStepClassifier1*jetCoreRegionalStepClassifier2*
jetCoreRegionalStep)
jetCoreRegionalStep.mva.min3DLayers = [1,2,3]
jetCoreRegionalStep.mva.maxLostLayers = [4,3,2]
jetCoreRegionalStep.mva.maxDz = [0.5,0.35,0.2];
jetCoreRegionalStep.mva.maxDr = [0.3,0.2,0.1];
jetCoreRegionalStep.vertices = 'firstStepGoodPrimaryVertices'
from RecoTracker.FinalTrackSelectors.TrackMVAClassifierPrompt_cfi import *
trackingPhase1.toReplaceWith(jetCoreRegionalStep, TrackMVAClassifierPrompt.clone(
src = 'jetCoreRegionalStepTracks',
mva = dict(GBRForestLabel = 'MVASelectorJetCoreRegionalStep_Phase1'),
qualityCuts = [-0.2,0.0,0.4],
))
trackingPhase1QuadProp.toReplaceWith(jetCoreRegionalStep, TrackMVAClassifierPrompt.clone(
src = 'jetCoreRegionalStepTracks',
mva = dict(GBRForestLabel = 'MVASelectorJetCoreRegionalStep_Phase1'),
qualityCuts = [-0.2,0.0,0.4],
))
# Final sequence
JetCoreRegionalStep = cms.Sequence(cms.ignore(jetsForCoreTracking)*
cms.ignore(firstStepGoodPrimaryVertices)*
#jetCoreRegionalStepClusters*
jetCoreRegionalStepSeedLayers*
jetCoreRegionalStepTrackingRegions*
jetCoreRegionalStepHitDoublets*
jetCoreRegionalStepSeeds*
jetCoreRegionalStepTrackCandidates*
jetCoreRegionalStepTracks*
# jetCoreRegionalStepClassifier1*jetCoreRegionalStepClassifier2*
jetCoreRegionalStep)
fileName=cms.untracked.string(
options.outFileName.split('.', 1)[0] + '_skim.root'),
SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring('p')),
dropMetaData=cms.untracked.string(
'DROPPED'), #'type_label_instance_process'
outputCommands=cms.untracked.vstring(outCommand))
## Event counters
from Analysis.EventCounter.eventcounter_cfi import eventCounter
process.allEvents = eventCounter.clone(isData=options.isData)
process.cleanedEvents = eventCounter.clone(isData=options.isData)
process.finalEvents = eventCounter.clone(isData=options.isData)
if options.sys:
process.p = cms.Path(
process.allEvents * process.evtcleaner * cms.ignore(process.ana) *
cms.ignore(process.anabcUp) * cms.ignore(process.anabcDown) *
cms.ignore(process.analightUp) * cms.ignore(process.analightDown) *
cms.ignore(process.anaJecUp) * cms.ignore(process.anaJecDown) *
cms.ignore(process.anaJerUp) * cms.ignore(process.anaJerDown) *
cms.ignore(process.anaPileupUp) * cms.ignore(process.anaPileupDown))
elif not options.sys and not options.isData:
process.p = cms.Path(process.allEvents * process.evtcleaner
#*process.cleanedEvents
* cms.ignore(process.ana)
#*cms.ignore(process.anaH)
#* process.finalEvents
)
else:
process.p = cms.Path(process.allEvents * process.evtcleaner *
cms.ignore(process.ana))
#create AK4 charged-hadron subtracted jets
process.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff")
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
process.ak4PFJets = ak4PFJets.clone()
process.ak4PFJetsCHS = ak4PFJets.clone(src = 'pfNoPileUpJME', doAreaFastjet = True)
#declare analyzer module
process.razorTriggerAnalysis = cms.EDAnalyzer("RazorTriggerAnalyzer",
trigSummary = cms.InputTag("hltTriggerSummaryAOD"),
pfMETCollection = cms.InputTag("pfMet"),
pfJetCollection = cms.InputTag("ak4PFJetsCHS"),
TriggerResults = cms.InputTag('TriggerResults','','reHLT'),
TriggerPath = cms.string('HLT_RsqMR300_Rsq0p09_MR200_v1'),
TriggerFilter = cms.InputTag('hltRsqMR300Rsq0p09MR200', '', 'reHLT'), #the last filter in the path
#CaloFilter = cms.InputTag('hltRsqMRNoMinRsqNoMinMRNoMinCalo', '', 'reHLT'), #filter implementing cuts on calo MR and Rsq
CaloFilter = cms.InputTag('hltRsqMR200Rsq0p01MR100Calo', '', 'reHLT'), #filter implementing cuts on calo MR and Rsq
hemispheres = cms.InputTag('hemispheres')
)
#define messagelogger (controls verbosity of the module)
process.MessageLogger = cms.Service("MessageLogger",
destinations = cms.untracked.vstring('detailedInfo','critical','cerr'),
critical = cms.untracked.PSet(threshold = cms.untracked.string('ERROR')),
detailedInfo = cms.untracked.PSet(threshold = cms.untracked.string('INFO') ),
cerr = cms.untracked.PSet(threshold = cms.untracked.string('WARNING') )
)
process.run_module = cms.Path(process.pfNoPileUpJMESequence*process.ak4PFJets*process.ak4PFJetsCHS*cms.ignore(process.hemispheres)*process.pfMet*process.razorTriggerAnalysis)
SelectEvents = cms.vstring('p3')
)
)
process.outp4 = cms.OutputModule("SewerModule",
shouldPass = cms.int32(5),
name = cms.string('p4'),
SelectEvents = cms.untracked.PSet(
SelectEvents = cms.vstring('p4')
)
)
process.outp5 = cms.OutputModule("SewerModule",
shouldPass = cms.int32(10),
name = cms.string('p5'),
SelectEvents = cms.untracked.PSet(
SelectEvents = cms.vstring('p5')
)
)
process.p1 = cms.Path(process.m1)
process.p2 = cms.Path(process.m1)
process.p3 = cms.Path(process.m1)
process.p4 = cms.Path(process.m1)
process.p5 = cms.Path(process.m4)
process.e1 = cms.EndPath(process.f1*process.outp1)
process.e2 = cms.EndPath(cms.ignore(process.f1)*process.outp2)
process.e3 = cms.EndPath(process.f2*process.m2*~process.f3*process.m3*cms.ignore(process.f4)*process.outp3)
process.e4 = cms.EndPath(process.f2*process.m2*~process.f3*cms.ignore(process.m3)*process.f4*process.outp4)
process.e5 = cms.EndPath(process.f2*process.m2*~process.f3*process.m3*cms.ignore(process.f4)*process.m4*process.outp5)
#
from DQM.TrackingMonitorSource.trackToTrackComparisonHists_cfi import trackToTrackComparisonHists
referenceTracksForHLTBTag = cms.EDFilter(
'TrackSelector',
src=cms.InputTag('generalTracks'),
cut=cms.string("quality('highPurity')"))
bTagHLTTrackMonitoring_muPF1 = trackToTrackComparisonHists.clone(
dzWRTPvCut=0.1,
monitoredTrack="hltMergedTracks",
referenceTrack="referenceTracksForHLTBTag",
monitoredBeamSpot="hltOnlineBeamSpot",
referenceBeamSpot="offlineBeamSpot",
topDirName="HLT/BTV/HLT_Mu12_DoublePFJets40_PFBTagDeepCSV_p71PF",
referencePrimaryVertices="offlinePrimaryVertices",
monitoredPrimaryVertices="hltVerticesPFSelector",
genericTriggerEventPSet=dict(
hltPaths=["HLT_Mu12_DoublePFJets40_PFBTagDeepCSV_p71*"]))
bTagHLTTrackMonitoring_muPF2 = bTagHLTTrackMonitoring_muPF1.clone(
topDirName=
"HLT/BTV/HLT_Mu12_DoublePFJets40MaxDeta1p6_DoublePFBTagDeepCSV_p71PF",
genericTriggerEventPSet=dict(hltPaths=[
"HLT_Mu12_DoublePFJets40MaxDeta1p6_DoublePFBTagDeepCSV_p71*"
]))
bTagHLTTrackMonitoringSequence = cms.Sequence(
cms.ignore(referenceTracksForHLTBTag) + bTagHLTTrackMonitoring_muPF1 +
bTagHLTTrackMonitoring_muPF2)
'eeBadScFilter',
'ecalLaserCorrFilter']
metFilters = cms.Sequence(
HBHENoiseFilter *
CSCTightHaloFilter *
hcalLaserEventFilter *
EcalDeadCellTriggerPrimitiveFilter *
goodVertices * trackingFailureFilter *
eeBadScFilter *
ecalLaserCorrFilter *
trkPOGFilters #*
#combinedbools
)
ignoreMetFilters = cms.Sequence(
cms.ignore(HBHENoiseFilterResultProducer) * #produces HBHENoiseFilterResult
cms.ignore(CSCTightHaloFilter) *
cms.ignore(hcalLaserEventFilter) *
cms.ignore(EcalDeadCellTriggerPrimitiveFilter) *
cms.ignore(goodVertices) * cms.ignore(trackingFailureFilter) *
cms.ignore(eeBadScFilter) *
cms.ignore(ecalLaserCorrFilter) *
#trkPOGFilters: give negative output
cms.ignore(manystripclus53X) *
cms.ignore(toomanystripclus53X) *
cms.ignore(logErrorTooManyClusters) *
combinedbools
)
'/store/mc/Phys14DR/TT_Tune4C_13TeV-pythia8-tauola/MINIAODSIM/PU40bx25_tsg_PHYS14_25_V1-v1/00000/06E41ADB-7870-E411-8850-0025905A605E.root'
#'/store/mc/Spring14miniaod/TTJets_MSDecaysCKM_central_Tune4C_13TeV-madgraph-tauola/MINIAODSIM/PU20bx25_POSTLS170_V5-v2/00000/004C6DA7-FB03-E411-96BD-0025905A497A.root'
#'file:/home/users/manuelf/cmssw/cfa/CMSSW_7_2_2_patch1/src/CfANtupler/minicfa/python/TT_Tune4C_13TeV-pythia8-tauola_MINIAODSIM.root'
))
process.load(
'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'PLS170_V7AN1::All' # GT for 25ns (asymptotic alignment and calibration scenario)
### Loading branches
process.load("CfANtupler/minicfa.branchesminicfA_cfi")
process.InputTagDistributorService = cms.Service("InputTagDistributorService")
process.VariableHelperService = cms.Service("VariableHelperService")
process.TFileService = cms.Service("TFileService",
fileName=cms.string('cfA.root'))
process.trackIsolationMaker = cms.EDProducer(
"TrackIsolationMaker",
pfCandidatesTag=cms.InputTag("packedPFCandidates"),
vertexInputTag=cms.InputTag("offlineSlimmedPrimaryVertices"),
dR_ConeSize=cms.double(0.3),
dz_CutValue=cms.double(0.05),
minPt_PFCandidate=cms.double(
5.0), #looser than the likely analysis selection
maxIso_PFCandidate=cms.double(0.25) #very loose
)
process.p = cms.Path(process.trackIsolationMaker)
process.outpath = cms.EndPath(cms.ignore(process.cfA))
from RecoLuminosity.LumiProducer.lumiProducer_cff import *
# import v0 monitoring
from DQM.TrackingMonitor.V0Monitor_cff import *
# better clone for now because goodOfflinePrimaryVertices is used also
# within the reco sequence, and without cloning framework will throw
# "unrunnable schedule" exception for workflows without --runUnscheduled
from CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi import goodOfflinePrimaryVertices
trackingDQMgoodOfflinePrimaryVertices = goodOfflinePrimaryVertices.clone()
# import PV resolution
from DQM.TrackingMonitor.primaryVertexResolution_cfi import *
# Sequence
TrackingDQMSourceTier0 = cms.Sequence(
cms.ignore(trackingDQMgoodOfflinePrimaryVertices))
# dEdx monitoring
TrackingDQMSourceTier0 += dedxHarmonicSequence * dEdxMonCommon * dEdxHitMonCommon
# # temporary patch in order to have BXlumi
# * lumiProducer
# track collections
for tracks in selectedTracks:
if tracks != 'generalTracks':
TrackingDQMSourceTier0 += cms.ignore(sequenceName[tracks])
label = 'TrackerCollisionSelectedTrackMonCommon' + str(tracks)
TrackingDQMSourceTier0 += cms.ignore(locals()[label])
# seeding monitoring
for _eraName, _postfix, _era in _cfg.allEras():
mvaSel = _utils.getMVASelectors(_postfix)
_seq = cms.Sequence()
for step in locals()["selectedIterTrackingStep" + _postfix]:
from Validation.RecoTrack.HLTmultiTrackValidator_cfi import *
hltMuonTrackValidator = hltMultiTrackValidator.clone(
label = [
"hltIter0HighPtTkMuPixelTracks",
"hltIter0HighPtTkMuTrackSelectionHighPurity",
"hltIter2HighPtTkMuTrackSelectionHighPurity",
"hltIter2HighPtTkMuMerged",
],
label_tp_effic = "trackingParticlesMuon",
label_tp_effic_refvector = True,
dirName = 'HLT/Muon/Tracking/ValidationWRTtp/',
## eta range driven by ECAL acceptance
histoProducerAlgoBlock = dict(
TpSelectorForEfficiencyVsEta = dict(ptMin = 24),
TpSelectorForEfficiencyVsPhi = dict(ptMin = 24),
TpSelectorForEfficiencyVsVTXR = dict(ptMin = 24),
TpSelectorForEfficiencyVsVTXZ = dict(ptMin = 24),
generalTpSelector = dict(ptMin = 24),
),
)
from Validation.RecoTrack.TrackValidation_cff import trackingParticlesElectron
trackingParticlesMuon = trackingParticlesElectron.clone(pdgId = [-13, 13])
hltMultiTrackValidationMuonTracks = cms.Sequence(
hltTPClusterProducer
+ hltTrackAssociatorByHits
+ cms.ignore(trackingParticlesMuon)
+ hltMuonTrackValidator
)
hltIter4V.trackCollectionForDrCalculation = cms.InputTag("hltIter4PFlowTrackSelectionHighPurity")
hltIter4MergedV = hltMultiTrackValidator.clone()
hltIter4MergedV.label = cms.VInputTag( cms.InputTag("hltIter4Merged") )
hltIter4MergedV.associatormap = cms.InputTag ( "tpToHLTiter4MergedTracksAssociation" )
hltIter4MergedV.trackCollectionForDrCalculation = cms.InputTag("hltIter4Merged")
from Validation.RecoTrack.cutsTPEffic_cfi import *
from Validation.RecoTrack.cutsTPFake_cfi import *
from SimGeneral.TrackingAnalysis.simHitTPAssociation_cfi import *
hltMultiTrackValidation = cms.Sequence(
# simHitTPAssocProducer
# +
hltTPClusterProducer
+ tpToHLTtracksAssociationSequence
+ cms.ignore(cutsTPEffic)
+ cms.ignore(cutsTPFake)
+ hltPixelTracksV
+ hltIter0V
+ hltIter1V
+ hltIter1MergedV
+ hltIter2V
+ hltIter2MergedV
# + hltIter3V
# + hltIter3MergedV
# + hltIter4V
# + hltIter4MergedV
)
tracksValidationSelectorsByAlgo +
tracksValidationSelectorsByAlgoHp +
cutsRecoTracksBtvLike +
ak4JetTracksAssociatorExplicitAll +
cutsRecoTracksAK4PFJets
)
tracksValidationTruth = cms.Sequence(
tpClusterProducer +
quickTrackAssociatorByHits +
trackingParticleRecoTrackAsssociation +
VertexAssociatorByPositionAndTracks
)
eras.fastSim.toModify(tracksValidationTruth, lambda x: x.remove(tpClusterProducer))
tracksValidationTruthSignal = cms.Sequence(
cms.ignore(trackingParticlesSignal) +
tpClusterProducerSignal +
quickTrackAssociatorByHitsSignal +
trackingParticleRecoTrackAsssociationSignal
)
eras.fastSim.toModify(tracksValidationTruthSignal, lambda x: x.remove(tpClusterProducerSignal))
tracksValidationTruthConversion = cms.Sequence(
trackingParticlesConversion +
tpClusterProducerConversion +
quickTrackAssociatorByHitsConversion
)
tracksPreValidation = cms.Sequence(
tracksValidationSelectors +
from ..sequences.HLTGsfElectronUnseededSequence_cfi import *
from ..sequences.HLTHgcalTiclPFClusteringForEgammaUnseeded_cfi import *
from ..sequences.HLTL1Sequence_cfi import *
from ..sequences.HLTPFClusteringForEgammaUnseeded_cfi import *
from ..sequences.HLTPFHcalClusteringForEgamma_cfi import *
from ..sequences.HLTTrackingV61Sequence_cfi import *
from ..tasks.HLTEle5WP70OpenUnseededTask_cfi import *
HLTEle5WP70OpenUnseededSequence = cms.Sequence(
HLTL1Sequence +
HLTDoFullUnpackingEgammaEcalSequence +
HLTPFClusteringForEgammaUnseeded +
HLTHgcalTiclPFClusteringForEgammaUnseeded +
hltEgammaCandidatesWrapperUnseeded +
hltEG5EtUnseededFilter +
cms.ignore(hltEle5WP70ClusterShapeUnseededFilter) +
cms.ignore(hltEle5WP70ClusterShapeSigmavvUnseededFilter) +
cms.ignore(hltEle5WP70ClusterShapeSigmawwUnseededFilter) +
cms.ignore(hltEle5WP70HgcalHEUnseededFilter) +
HLTDoLocalHcalSequence +
HLTFastJetForEgamma +
cms.ignore(hltEle5WP70HEUnseededFilter) +
cms.ignore(hltEle5WP70EcalIsoUnseededFilter) +
cms.ignore(hltEle5WP70HgcalIsoUnseededFilter) +
HLTPFHcalClusteringForEgamma +
cms.ignore(hltEle5WP70HcalIsoUnseededFilter) +
HLTElePixelMatchUnseededSequence +
cms.ignore(hltEle5WP70PixelMatchUnseededFilter) +
cms.ignore(hltEle5WP70PMS2UnseededFilter) +
HLTGsfElectronUnseededSequence +
cms.ignore(hltEle5WP70GsfOneOEMinusOneOPUnseededFilter) +
elif moduleName.startswith("cms.ignore"):
moduleName = moduleName.lstrip("cms.ignore(process.")
moduleName = moduleName.rstrip(")")
module = getattr(process,moduleName)
path.replace(obj,module)
if type(obj).__name__=="Sequence":
rmOperatorsFromFilters(process,obj)
if runOpen:
for pathName in process.pathNames().split():
path = getattr(process,pathName)
rmOperatorsFromFilters(process,path)
for filterName in path.moduleNames():
filt = getattr(process,filterName)
if type(filt).__name__=="EDFilter":
path.replace(filt,cms.ignore(filt))
def cleanList(input,blacklist):
output = set()
for x in input:
if x not in blacklist:
output.add(x)
#print output
return output
productsToKeep = set()
for pathName in process.pathNames().split():
path = getattr(process,pathName)
for filterName in path.moduleNames():
#print filterName
# the filter decisions, if there are any, from the objects
# specified. This lets us be sure that if an object is not written to
# disk, it is because it failed our own jet/lepton multiplicity
# filters.
#
# And as a final note, just because all these modules are on three
# paths, they won't be run three times per event. CMSSW knows to run
# e.g. patJetsPF only once, then reuse the results. We specify it this
# way to be clear to CMSSW that each path needs to have the PAT
# modules ran before running the modules specific to each Path.
process.patJetPartonMatch1 = process.patJetPartonMatch.clone(
src=cms.InputTag("selectedPatJetsPF"), mcStatus=[1])
if runOnMC:
base_path = cms.ignore(process.goodOfflinePrimaryVertices) + \
cms.ignore(process.mvaTrigV0) + \
cms.ignore(process.mvaNonTrigV0) + \
process.patPF2PATSequencePF + \
process.patJetPartonMatch1
else:
base_path = cms.ignore(process.goodOfflinePrimaryVertices) + \
cms.ignore(process.mvaTrigV0) + \
cms.ignore(process.mvaNonTrigV0) + \
process.patPF2PATSequencePF
#process.patPF2PATSequencePF.replace(process.patJetPartonMatchPF, process.patJetPartonMatch1)
process.pSemileptonic = cms.Path(base_path +
process.countPatJetsSemileptonicPF +
process.semilepMuonsPF +
import FWCore.ParameterSet.Config as cms
from RecoEgamma.ElectronIdentification.electronIdMVABased_cfi import *
electronsWithPresel = cms.EDFilter(
"GsfElectronSelector",
src=cms.InputTag("ecalDrivenGsfElectrons"),
cut=cms.string("pt > 5 && ecalDrivenSeed && passingCutBasedPreselection"),
)
mvaElectrons.electronTag = cms.InputTag('electronsWithPresel')
pfGsfElectronMVASelectionSequence = cms.Sequence(
cms.ignore(electronsWithPresel) + mvaElectrons)
def testNoSchedule(self):
import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.a = cms.EDProducer("AProd")
process.b = cms.EDProducer("BProd")
process.c = cms.EDProducer("CProd")
process.d = cms.EDProducer("DProd", par1=cms.InputTag("f1"))
process.e = cms.EDProducer("EProd",
par1=cms.VInputTag(
cms.InputTag("x"),
cms.InputTag("f1", "y")))
process.f = cms.EDProducer("FProd",
par1=cms.VInputTag("x", "y", "f1"))
process.g = cms.EDProducer("GProd", par1=cms.InputTag("f"))
process.h = cms.EDProducer(
"HProd",
par1=cms.bool(True),
par2=cms.PSet(par21=cms.VPSet(
cms.PSet(foo=cms.bool(True)),
cms.PSet(foo4=cms.PSet(
bar=cms.bool(True),
foo1=cms.InputTag("f1"),
foo2=cms.VInputTag(cms.InputTag("x"),
cms.InputTag("f11", "y")),
foo3=cms.VInputTag("q", "r", "s"))))))
process.k = cms.EDProducer(
"KProd",
par1=cms.bool(True),
par2=cms.PSet(par21=cms.VPSet(
cms.PSet(foo=cms.bool(True)),
cms.PSet(foo4=cms.PSet(bar=cms.bool(True),
xSrc=cms.string("f"))))))
process.f1 = cms.EDFilter("Filter")
process.f2 = cms.EDFilter("Filter2")
process.f3 = cms.EDFilter("Filter3")
process.f4 = cms.EDFilter("FIlter4")
process.p1 = cms.Path(process.a + process.b + process.f1 +
process.d + process.e + process.f +
process.g + process.h + process.k)
process.p4 = cms.Path(process.a + process.f2 + process.b +
~process.f1 + cms.ignore(process.f4))
process.p2 = cms.Path(process.a + process.b)
process.p3 = cms.Path(process.f1)
convertToUnscheduled(process)
self.assertEqual(process.options.allowUnscheduled,
cms.untracked.bool(True))
self.assert_(hasattr(process, 'p2'))
self.assert_(hasattr(process, 'a'))
self.assert_(hasattr(process, 'b'))
self.assert_(not hasattr(process, 'c'))
self.assert_(hasattr(process, 'd'))
self.assert_(hasattr(process, 'e'))
self.assert_(hasattr(process, 'f'))
self.assert_(hasattr(process, 'g'))
self.assert_(hasattr(process, 'f1'))
self.assert_(hasattr(process, 'f2'))
self.assert_(not hasattr(process, 'f3'))
self.assert_(hasattr(process, 'f4'))
self.assertEqual(
process.p1.dumpPython(None),
'cms.Path(process.f1+process.d+process.e+process.f+process.g+process.h+process.k)\n'
)
self.assertEqual(process.p2.dumpPython(None), 'cms.Path()\n')
self.assertEqual(process.p3.dumpPython(None),
'cms.Path(process.f1)\n')
self.assertEqual(
process.p4.dumpPython(None),
'cms.Path(process.f2+~process.f1+cms.ignore(process.f4))\n')
process.load("FWCore.MessageService.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = 1000
process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1))
process.source = cms.Source(
"PoolSource",
# replace 'myfile.root' with the source file you want to use
fileNames=cms.untracked.vstring(
# 'file:myfile.root'
'file:/tmp/adamwo/Hermine/src/JpsiMM_cfi_py_GEN_SIM.root'))
process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(True))
process.demo = cms.EDFilter('MuonSimHitCountFilter',
simTracks=cms.InputTag("g4SimHits"),
simHits=cms.VInputTag(
cms.InputTag("g4SimHits", "MuonCSCHits"),
cms.InputTag("g4SimHits", "MuonDTHits")),
minHitsChamber=cms.vint32(2, 2),
minHitsSubDet=cms.vint32(2, 2),
minHitsTotal=cms.int32(-1),
particleTypes=cms.vint32(-13, 13),
processTypes=cms.vint32())
process.p = cms.Path(cms.ignore(process.demo))
process.out = cms.OutputModule("PoolOutputModule",
fileName=cms.untracked.string('test.root'))
process.outPath = cms.EndPath(process.out)
do_generic_sim_plots = False,
trackAssociatorMap = "trackingParticlePixelTrackAsssociation",
vertexAssociator = "PixelVertexAssociatorByPositionAndTracks",
vertexRecoCollections = [
"pixelVertices",
"selectedPixelVertices"
]
)
pixelVertexAnalysisPixelTrackingOnly = pixelVertexAnalysisTrackingOnly.clone(
do_generic_sim_plots = True,
)
##########
vertexAnalysisSelection = cms.Sequence(
cms.ignore(selectedOfflinePrimaryVertices)
+ cms.ignore(selectedOfflinePrimaryVerticesWithBS)
)
##########
vertexAnalysisSequence = cms.Sequence(
vertexAnalysisSelection
+ vertexAnalysis
)
vertexAnalysisSequenceTrackingOnly = cms.Sequence(
vertexAnalysisSelection
+ vertexAnalysisTrackingOnly
)
)
process.bTagValidation = cms.Sequence(
process.caloBTagAnalysis +
process.pfBTagAnalysis
)
process.plots = cms.Path(
process.bit40 +
process.bptxAnd +
# process.physDecl +
process.singleJetHLTFilter +
process.noscraping +
process.oneGoodVertexFilter +
process.ak5PFJetsL2L3 *
cms.ignore(process.PFJetsFilter) *
process.ak5JetID *
cms.ignore(process.caloJetIDFilter) *
process.ak5CaloJetsL2L3 *
process.trackAssociation *
process.ipTagInfos *
process.svTagInfos *
process.ipTaggers *
process.svTaggers *
process.slTagInfos *
process.slTaggers *
process.bTagNtuples *
process.HLT_Jet15U *
process.bTagValidation *
process.MEtoEDMConverter
)
# selectedPixelVertices.src = cms.InputTag('pixelVertices')
vertexAnalysis = cms.EDAnalyzer(
"PrimaryVertexAnalyzer4PUSlimmed",
use_only_charged_tracks=cms.untracked.bool(True),
verbose=cms.untracked.bool(False),
sigma_z_match=cms.untracked.double(3.0),
abs_z_match=cms.untracked.double(0.1),
root_folder=cms.untracked.string("Vertexing/PrimaryVertexV"),
recoTrackProducer=cms.untracked.InputTag("generalTracks"),
trackingParticleCollection=cms.untracked.InputTag("mix", "MergedTrackTruth"),
trackingVertexCollection=cms.untracked.InputTag("mix", "MergedTrackTruth"),
trackAssociatorMap=cms.untracked.InputTag("trackingParticleRecoTrackAsssociation"),
vertexAssociator=cms.untracked.InputTag("VertexAssociatorByPositionAndTracks"),
vertexRecoCollections=cms.VInputTag(
"offlinePrimaryVertices",
"offlinePrimaryVerticesWithBS",
# "pixelVertices",
"selectedOfflinePrimaryVertices",
"selectedOfflinePrimaryVerticesWithBS",
# "selectedPixelVertices"
),
)
vertexAnalysisSequence = cms.Sequence(
cms.ignore(selectedOfflinePrimaryVertices)
* cms.ignore(selectedOfflinePrimaryVerticesWithBS)
# * cms.ignore(selectedPixelVertices)
* vertexAnalysis
)
"&& globalTrack.isNonnull"
"&& passed('CutBasedIdTight')"),
filter=cms.bool(False))
gemEfficiencyAnalyzerTightGlb = gemEfficiencyAnalyzer.clone(
muonTag="gemDQMTightGlbMuons",
muonTrackType="CombinedTrack",
startingStateType="OutermostMeasurementState",
folder="GEM/Efficiency/muonGLB",
muonName="Tight GLB Muon",
propagationErrorRCut=0.5, # cm
propagationErrorPhiCut=0.1, # degree
)
gemEfficiencyAnalyzerTightGlbSeq = cms.Sequence(
cms.ignore(gemDQMTightGlbMuons) * gemEfficiencyAnalyzerTightGlb)
################################################################################
# Standalone muons
################################################################################
gemDQMStaMuons = cms.EDFilter("MuonSelector",
src=cms.InputTag("muons"),
cut=cms.string("isStandAloneMuon"
"&& outerTrack.isNonnull"),
filter=cms.bool(False))
gemEfficiencyAnalyzerSta = gemEfficiencyAnalyzer.clone(
muonTag="gemDQMStaMuons",
muonTrackType="OuterTrack",
startingStateType="OutermostMeasurementState",
folder="GEM/Efficiency/muonSTA",
