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",