Exemple #1
0
    def jet(self) :
        jetJecFileName = 'Summer13_V5_DATA_UncertaintySources_AK5PFchs.txt'
        jetJecFile = os.popen('find . | grep %s | head -1' % jetJecFileName).read().strip()
        jetResFile = '%s/src/CondFormats/JetMETObjects/data/Spring10_PtResolution_AK5PF.txt'%os.environ['CMSSW_RELEASE_BASE']
        self.process.tupleJet = cms.EDProducer("Tuple_PatJet",
                                               prefix = cms.string("jet"),
                                               jetsTag = tags("selectedPatJetsForAnalysis"),
                                               allJetsTag = tags("selectedPatJets"+self.options.postfix),
                                               jecRecord = cms.string("AK5PFchs"),
                                               jecNames = cms.vstring([""]+self.availableJecUncertainties()),
                                               bTags = cms.vstring(self.options.btags),
                                               pfInfo = cms.bool(True),
                                               genInfo = cms.bool( not self.options.isData),
                                               jetResolutionFile = cms.string(jetResFile.split('/')[-1]),
                                               jetUncertaintyFile = cms.string(jetJecFileName),

                                               # https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution
                                               resolutionRatioBins = cms.vdouble(0.0, 0.5, 1.1, 1.7, 2.3, 5.0),
                                               resolutionRatio = cms.vdouble(1.052, 1.057, 1.096, 1.134, 1.288),
                                               resolutionRatioErr = cms.vdouble( math.sqrt( 0.012**2 + 0.0615**2 ),
                                                                                 math.sqrt( 0.012**2 + 0.0555**2 ),
                                                                                 math.sqrt( 0.017**2 + 0.0625**2 ),
                                                                                 math.sqrt( 0.035**2 + 0.086**2  ),
                                                                                 math.sqrt( 0.127**2 + 0.154**2  )
                                                                                 )
                                               )
        os.system("cp %s ."%jetResFile)
        os.system("cp %s ."%jetJecFile)
        return self.empty + self.process.tupleJet
  def reduce(self, sort):
    # reduce can be MEAN or COUNT. in STAGE2, just pass through.
    # in STAGE1, MEAN (anywhere) means make a PROFILE
    # COUNT can mean per-event counting or a occupancy plot, which is acheived
    # by ignoring the values passed to fill() (like dimensions=0, TODO).
    if self._state == FIRST:
      if sort != "COUNT":
        raise Exception("First statement must be groupBy.")
      self.spec[0].type = COUNT # this is actually a noop
      # groupBy already saw the "Event" column and set up counting.

      return self

    if self._state == STAGE1:
      if sort == "MEAN":
        self.spec.append(cms.PSet(
          type = PROFILE, stage = STAGE1,
          columns = cms.vstring(), arg = cms.string(""),
          nbins = cms.int32(-1), xmin = cms.int32(0), xmax = cms.int32(0)
        ))
      return self

    if sort != "MEAN":
      raise Exception("Harvesting allows only reduce(MEAN) at the moment, not " + sort)

    self.spec.append(cms.PSet(
      type = REDUCE, 
      stage = self._state, 
      columns = cms.vstring(),
      arg = cms.string(sort),
      nbins = cms.int32(-1), xmin = cms.int32(0), xmax = cms.int32(0)
    ))
    return self
def configurePlotWtoTauNuIntegrated(meName_data, meName_mc, meName_compatibility,
                                    plotName, plotTitle,
                                    outputFileName):
    drawTemplateHistConfiguratorWtoTauNuIntegrated = drawTemplateHistConfigurator(
        template = drawJobTemplateHistIntegrated.clone(
        labels = cms.vstring('ksProb')
        )
        )
    drawTemplateHistConfiguratorWtoTauNuIntegrated.add(
        meNames = [ meName_data, meName_mc ],
        name = plotName,
        title = plotTitle
        )
    plotHistWtoTauNuIntegrated = plotHistWtoTauNu.clone(
        labels = cms.PSet(
           ksProb = label_mcNormScale.clone(
               text = cms.vstring('KS prob.: %f1.2'),
               meName = cms.string(meName_compatibility)
               )
           ),
        drawJobs = drawTemplateHistConfiguratorWtoTauNuIntegrated.configure(),
        indOutputFileName = cms.string(outputFileName)
        )
    
    return plotHistWtoTauNuIntegrated
Exemple #4
0
    def makeAnalysisStep(self, stepName, **inputs):
        step = super(BJetCounters, self).makeAnalysisStep(stepName, **inputs)
        
        if stepName == 'initialStateEmbedding':
            # Recommendations via https://twiki.cern.ch/twiki/bin/viewauth/CMS/BtagRecommendation80XReReco
            jetCounters = {
                "CSVv2L" : '? bDiscriminator("pfCombinedInclusiveSecondaryVertexV2BJetTags") > 0.5426 ? 1 : 0',
                "CSVv2M" : '? bDiscriminator("pfCombinedInclusiveSecondaryVertexV2BJetTags") > 0.8484 ? 1 : 0',
                "CSVv2T" : '? bDiscriminator("pfCombinedInclusiveSecondaryVertexV2BJetTags") > 0.9535 ? 1 : 0',
                "CMVAv2L" : '? bDiscriminator("pfCombinedMVAV2BJetTags") > -0.5884 ? 1 : 0',
                "CMVAv2M" : '? bDiscriminator("pfCombinedMVAV2BJetTags") > 0.4432 ? 1 : 0',
                "CMVAv2T" : '? bDiscriminator("pfCombinedMVAV2BJetTags") > 0.9432 ? 1 : 0',
            }
            mod = cms.EDProducer(
                "PATJetCounter",
                src = step.getObjTag('j'),
                labels = cms.vstring(*['nJet'+label for label in jetCounters.keys()]),
                cuts = cms.vstring(*[jetCounters[key] for key in jetCounters.keys()])
                )
            step.addModule("jetCounter", mod)

            labels = ['nJet'+name for name in jetCounters.keys()]
            tags = [cms.InputTag("jetCounter:nJet"+name) for name in jetCounters.keys()]

            for chan in parseChannels('zl'):
                countEmbedding = cms.EDProducer(
                    'PATCompositeCandidateValueEmbedder',
                    src = step.getObjTag(chan),
                    intLabels = cms.vstring(*labels),
                    intSrc = cms.VInputTag(*tags),
                    )
                step.addModule(chan+'JetCountEmbedding', countEmbedding, chan)

        return step
def CMGWPswitchToPFJets(process) :

    addJetCollection(process,cms.InputTag('newAK7PF'),'AK7','PF',
                     doJTA        = True,
                     doBTagging   = True,
                     jetCorrLabel = ('AK7PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])),
                     doType1MET   = True,
                     genJetCollection=cms.InputTag("ak7GenJets"),
                     doJetID      = False
                     )
    


    addJetCollection(process,cms.InputTag('ak5PFJets'),'AK5','PF',
                                          doJTA        = True,
                                          doBTagging   = True,
                                          jetCorrLabel = ('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])),
                                          doType1MET   = True,
                                          genJetCollection=cms.InputTag("ak5GenJets"),
                                          doJetID      = False
                                          )

    

    process.selectedPatPFParticles.cut = ""


    from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
    process.goodOfflinePrimaryVertices = cms.EDFilter(
        "PrimaryVertexObjectFilter",
        filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ),
        src=cms.InputTag('offlinePrimaryVertices')
        )
Exemple #6
0
def customise(process, dataVersion):
    name = dataVersion.getTriggerProcess()

    if hasattr(process, "patTrigger"):
        process.patTrigger.processName = name
        process.patTriggerEvent.processName = name

    process.HLTREDIGI = cms.EDFilter('HPlusTriggering',
        TriggerResultsName = cms.InputTag("TriggerResults", "", name),
        TriggersToBeApplied = cms.vstring(
        ),
        TriggersToBeSaved = cms.vstring(
        "HLT_SingleLooseIsoTau20",
        "HLT_MET45",
        "HLT_MET100",
        "HLT_Jet15U",
        "HLT_Jet30U",
        "HLT_Jet50U",
        "HLT_QuadJet15U",
        "HLT_Mu9"
        ),
        PrintTriggerNames = cms.bool(False)
    )
    process.HChTriggers = cms.Sequence( process.HLTREDIGI )

    return process
Exemple #7
0
def dqmIOSource(args):
    import FWCore.ParameterSet.Config as cms

    if args.get("newDQMIO", False):
        return cms.Source("DQMRootSource", fileNames=cms.untracked(cms.vstring()))
    else:
        return cms.Source("PoolSource", fileNames=cms.untracked(cms.vstring()))
def customise(process):

    # fragment allowing to simulate neutron background in muon system

  if hasattr(process,'g4SimHits'):
    # time window 100 millisecond
    process.common_maximum_time.MaxTrackTime = cms.double(100000000.0)
    process.common_maximum_time.DeadRegions = cms.vstring()
    # Physics List HP
    process.g4SimHits.Physics.type = cms.string('SimG4Core/Physics/FTFP_BERT_HP_EML')
    process.g4SimHits.Physics.CutsOnProton  = cms.untracked.bool(False)
    process.g4SimHits.Physics.FlagMuNucl  = cms.bool(True)
    process.g4SimHits.Physics.FlagFluo    = cms.bool(True)
    # Eta cut
    process.g4SimHits.Generator.MinEtaCut = cms.double(-7.0)
    process.g4SimHits.Generator.MaxEtaCut = cms.double(7.0)
    # stacking action
    process.g4SimHits.StackingAction.MaxTrackTime = cms.double(100000000.0)
    process.g4SimHits.StackingAction.DeadRegions = cms.vstring()
    process.g4SimHits.StackingAction.KillHeavy = cms.bool(True)
    process.g4SimHits.StackingAction.IonThreshold = cms.double(0.001)
    process.g4SimHits.StackingAction.ProtonThreshold = cms.double(0.001)
    process.g4SimHits.StackingAction.NeutronThreshold = cms.double(0.0)
    process.g4SimHits.StackingAction.GammaThreshold = cms.double(0.0005)
    # stepping action
    process.g4SimHits.SteppingAction.MaxTrackTime = cms.double(100000000.0)
    process.g4SimHits.SteppingAction.DeadRegions = cms.vstring()
    # Russian roulette disabled
    process.g4SimHits.StackingAction.RusRoGammaEnergyLimit = cms.double(0.0)
    process.g4SimHits.StackingAction.RusRoNeutronEnergyLimit = cms.double(0.0)
    # full simulation of HF 
    process.g4SimHits.HFShower.UseHFGflash = cms.bool(False)

    return(process)
Exemple #9
0
def switchToAOD(process, triggerHistManager = None, eventDumpPlugin = None):

    # call "standard" PAT function to restrict all InputTags to AOD event content
    restrictInputToAOD(process, [ "All", ])

    # switch collection of ECAL recHits used as input for IsoDeposit computation
    # from list of all ECAL recHits in the event to "reduced" collections
    # limited to cones of size dR = 0.6 around electron candidates
    if hasattr(process, "p"):
        massSearchReplaceAnyInputTag(process.p, cms.InputTag("ecalRecHit", "EcalRecHitsEB"), cms.InputTag("reducedEcalRecHitsEB"))
        massSearchReplaceAnyInputTag(process.p, cms.InputTag("ecalRecHit", "EcalRecHitsEE"), cms.InputTag("reducedEcalRecHitsEE")) 

    # disable PAT trigger matching
    # (not yet implemented for photons and jets)
    if hasattr(process, "patTriggerSequence"):
        process.patDefaultSequence.remove(process.patTriggerSequence)
    process.patElectrons.embedHighLevelSelection = cms.bool(False)
    #process.patPhotons.embedHighLevelSelection = cms.bool(False)
    process.patMuons.embedHighLevelSelection = cms.bool(False)
    process.patTaus.embedHighLevelSelection = cms.bool(False)
    #process.patJets.embedHighLevelSelection = cms.bool(False)
    process.patMETs.embedHighLevelSelection = cms.bool(False)
    if hasattr(process, "patPFMETs"):
        process.patPFMETs.embedHighLevelSelection = cms.bool(False)

    if triggerHistManager is not None:
        triggerHistManager.hltResultsSource = cms.InputTag('')
        triggerHistManager.l1Bits = cms.vstring()
        triggerHistManager.hltPaths = cms.vstring()
       
    if eventDumpPlugin is not None:
        eventDumpPlugin.l1GtReadoutRecordSource = cms.InputTag('')
        eventDumpPlugin.l1GtObjectMapRecordSource = cms.InputTag('')
        eventDumpPlugin.hltResultsSource = cms.InputTag('')
def get(todo):
    defs = {}
    defs["JetViewPFAK4CHS"]  = cms.PSet(
        miniView = cms.string("JetView"),
        storeageVersion = cms.untracked.int32(1),
        disableJetID = cms.bool(True),
        optionalCaloJets4ID = cms.InputTag("ak5CaloJets","","RECO"),
        optionalCaloID4ID  = cms.InputTag("ak5JetID"),
        branchPrefix = cms.untracked.string("PFAK4CHS"),
        maxEta = cms.double(5.2),
        minPt = cms.double(3),
        maxnum = cms.int32(3),
        input = cms.InputTag("selectedPatJetsAK4PFCHSCopy"),
        variations= cms.vstring("", "jecUp", "jecDown"),
        jerFactors = cms.vstring(  # PF10
                "5.5 1 0.007 0.07 0.072"),
    )
    # and so on
    # defs["JetViewAK4Calo"]= cmsPSet(...

    ret = {}
    for t in todo:
        if t not in defs:
            raise Exception("miniView def not known "+t)

        ret[t] = defs[t]
    return ret
def reproduceJEC(process):
    '''
    For instructions and more details see:
    https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#CorrPatJets
    https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD2016#Jets
    https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetAnalysis
    '''
    print "=== Customisation: reproducing jet collections with latest JEC"
    from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
    updateJetCollection(
        process,
        # jetSource = cms.InputTag('slimmedJets'),
        jetSource = cms.InputTag('cleanedPatJets'),
        labelName = 'UpdatedJEC',
        jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None')  # Do not forget 'L2L3Residual' on data!
    )
    # PUPPI jets
    updateJetCollection(
        process,
        jetSource = cms.InputTag('slimmedJetsPuppi'),
        labelName = 'UpdatedJECPuppi',
        jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None')  # Do not
    )
    
    # Add to customisations sequence
    process.CustomisationsSequence += process.patJetCorrFactorsUpdatedJEC
    process.CustomisationsSequence += process.updatedPatJetsUpdatedJEC
    process.CustomisationsSequence += process.patJetCorrFactorsUpdatedJECPuppi
    process.CustomisationsSequence += process.updatedPatJetsUpdatedJECPuppi
Exemple #12
0
def makeCategoryParams(llWPs=[], diLeptonTriggerMatch=False, addPassAll=False):
    categs = dict() ## take dilepton working points from input
    for l1 in ("El", "Mu"):
        for l2 in ("El", "Mu"):
            flav = "".join((l1,l2))
            base = cms.PSet(
                      NElectrons = cms.uint32(sum( 1 for l in (l1,l2) if l == "El" ))
                    , NMuons     = cms.uint32(sum( 1 for l in (l1,l2) if l == "Mu" ))
                    , Category   = cms.string("is{0}".format(flav))
                    , HLT        = cms.vstring(dileptonTriggers[flav]) if diLeptonTriggerMatch else cms.vstring()
                    , Cuts       = cms.VPSet(
                                        cms.PSet(Mll   = cms.string("p4.M > 20"))
                                      , cms.PSet(ZVeto = cms.string("( p4.M < 76 ) || ( p4.M > 116 )"))
                                      )
                    , WPs=cms.vstring(llWPs)
                    )
            categs["{0}OS".format(flav)]    = base.clone(Charge=cms.int32( 0), Category=cms.string("is{0} && isOS".format(flav)))
            categs["{0}Plus".format(flav)]  = base.clone(Charge=cms.int32( 1))
            categs["{0}Minus".format(flav)] = base.clone(Charge=cms.int32(-1))
    if addPassAll:
        categs["all"] = cms.PSet(
                  NElectrons = cms.uint32(0)
                , NMuons     = cms.uint32(0)
                , Category   = cms.string("")
                , HLT        = cms.vstring()
                , Cuts       = cms.VPSet()
                , WPs        = cms.vstring()
                , Charge     = cms.int32(0)
                )

    return cms.PSet(**categs)
def setupStauProduction (process, stauMass, particlesLSHAFile) :
    return cms.EDFilter("Pythia6GeneratorFilter",
                        pythiaPylistVerbosity = cms.untracked.int32(2),
                        filterEfficiency = cms.untracked.double(0.701),
                        pythiaHepMCVerbosity = cms.untracked.bool(True),
                        comEnergy = cms.double(10000.0),
                        crossSection = cms.untracked.double(1232),
                        maxEventsToPrint = cms.untracked.int32(2),
                        gluinoHadrons =  cms.bool(True),  
                        
                        PythiaParameters = cms.PSet(
        pythiaUESettings = UESettings (),
        processParameters = cms.vstring(
        'MSEL=39                  ! All SUSY processes ',
        'IMSS(1) = 11             ! Spectrum from external SLHA file',
        'IMSS(21) = 33            ! LUN number for SLHA File (must be 33) ',
        'IMSS(22) = 33            ! Read-in SLHA decay table ',
        'MDCY(C1000015,1)=0       ! set the stau stable.'
        ),
        parameterSets = cms.vstring(
        'pythiaUESettings', 
        'processParameters',
        'SLHAParameters'
        ),
        SLHAParameters = cms.vstring('SLHAFILE = %s' % particlesLSHAFile)
        )
                        )
def get(todo):
    defs = {}

    # ZeroBias trigger configuration
    defs["ZeroBiasTriggerResultsView"]  = cms.PSet(
        miniView = cms.string("TriggerResultsView"),
        branchPrefix = cms.untracked.string("trg"),
        process = cms.string("HLT"),
        triggers = cms.vstring("ZeroBias"),
        ZeroBias = cms.vstring("HLT_ZeroBias_part*")
    )

    defs["L1GTriggerResultsView"] = cms.PSet(
        miniView = cms.string("TriggerResultsView"),
        branchPrefix = cms.untracked.string("trgl1"),
        process = cms.string("HLT"),
        triggers = cms.vstring("L1GTTech","L1GTAlgo")
    )
 
    # main function
    ret = {}
    for t in todo:
        if t not in defs:
            raise Exception("miniView def not known "+t)

        ret[t] = defs[t]
    return ret
Exemple #15
0
  def reduce(self, sort):
    if self._state == FIRST:
      if sort != "COUNT":
        raise Exception("First statement must be groupBy.")
      self.spec[0].type = COUNT # this is actually a noop
      # groupBy already saw the "Event" column and set up counting.

      return self

    if self._state == STAGE1:
      if sort == "MEAN":
        self.spec.append(cms.PSet(
          type = PROFILE, stage = STAGE1,
          columns = cms.vstring(), arg = cms.string("")
        ))
      return self

    if sort != "MEAN":
      raise Exception("Harvesting allows only reduce(MEAN) at the moment, not " + sort)

    self.spec.append(cms.PSet(
      type = REDUCE, 
      stage = self._state, 
      columns = cms.vstring(),
      arg = cms.string(sort)
    ))
    return self
    def configure(self):
        # return configuration object
        # for set of drawJobs

        for iPlot in range(len(self.plots)):

            drawJob = copy.deepcopy(self.template)

            dqmSubDirectory = self.dqmSubDirectories[iPlot]

            dqmDirectory = self.dqmDirectory
            if dqmSubDirectory != "":
                dqmDirectory += dqmSubDirectory
            if not dqmDirectory.endswith("/"):
                dqmDirectory += "/"

            plot = self.plots[iPlot]

            dqmMonitorElement = dqmDirectory + getattr(plot, "meName")

            setattr(drawJob.plots, "dqmMonitorElements", cms.vstring([ dqmMonitorElement, ]))
            if hasattr(plot, "PAR"):
                setattr(drawJob, "parameter", cms.vstring(getattr(plot, "PAR")))
            setattr(drawJob, "title", cms.string(getattr(plot, "title")))
            setattr(drawJob, "xAxis", cms.string(getattr(plot, "xAxis")))

            # add drawJob configuration to set of drawJobs
            setattr(self.drawJobs, getattr(plot, "name"), drawJob)

        return self.drawJobs
def eventPreselection(process, preselection):
    # choose preselection to apply
    if preselection == "DoubleMu":
        process.firstLevelPreselection = process.MuonPreselectionCuts
        process.secondLevelPreselection = process.DoubleMuPreselectionCuts
    elif preselection == "DoubleEle":
        process.firstLevelPreselection = process.ElePreselectionCuts
        process.secondLevelPreselection = process.DoubleElePreselectionCuts
    elif preselection == "EMuTvariable":
        process.firstLevelPreselection = process.MuOrElePreselectionCuts
        process.secondLevelPreselection = process.EMuTvariablePreselectionCuts
    elif preselection == "MuTau":
        process.firstLevelPreselection = process.MuonPreselectionCuts
        process.secondLevelPreselection = process.MuTauPreselectionCuts
    else:
        process.firstLevelPreselection = process.MuonPreselectionCuts
        process.secondLevelPreselection = process.NoPreselectionCuts
    
    # HLT paths to use
    process.MultiTrigFilter.useTriggers = cms.vstring("HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v","HLT_IsoMu18_eta2p1_LooseIsoPFTau20_v", # for mu+tau analyses
                                                      "HLT_IsoMu24_eta2p1_v", # for claudia and possible trigger efficiency measurements
                                                      "HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL","HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL", # for e+mu analysis
                                                      "HLT_Mu17_Mu8_v","HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v","HLT_Ele27_WP80_v" # for trigger efficiency measurements
                                                      )
    # HLT modules in used HLT paths
    process.NtupleMaker.useFilterModules = cms.vstring("hltOverlapFilterIsoMu17LooseIsoPFTau20","hltL3crIsoL1sMu14erORMu16erL1f0L2f14QL3f17QL3crIsoRhoFiltered0p15", # HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v
                                                       "hltOverlapFilterIsoMu18LooseIsoPFTau20","hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f18QL3crIsoFiltered10", # HLT_IsoMu18_eta2p1_LooseIsoPFTau20_v
                                                       "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15","hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoFiltered10", # HLT_IsoMu24_eta2p1_v
                                                       "hltMu17Ele8CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter","hltL1Mu12EG7L3MuFiltered17", # HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL
                                                       "hltMu8Ele17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter","hltL1sL1Mu3p5EG12ORL1MuOpenEG12L3Filtered8","hltL1MuOpenEG12L3Filtered8", # HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL
                                                       "hltDiMuonGlb17Glb8DzFiltered0p2","hltL3fL1DoubleMu10MuOpenOR3p5L1f0L2f10L3Filtered17","hltL3fL1DoubleMu10MuOpenL1f0L2f10L3Filtered17","hltDiMuonMu17Mu8DzFiltered0p2","hltL3pfL1DoubleMu10MuOpenOR3p5L1f0L2pf0L3PreFiltered8","hltL3pfL1DoubleMu10MuOpenL1f0L2pf0L3PreFiltered8" # HLT_Mu17_Mu8_v
                                                       "hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoDZ", # HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v
                                                       "hltEle27WP80TrackIsoFilter" # HLT_Ele27_WP80_v
                                                       )
def makeJetVarsHadTau(process,sequence,JetTag,suff,storeProperties=0):
    if hasattr(process,sequence):
        theSequence = getattr(process,sequence)
    else:
        print "Unknown sequence: "+sequence
        return

    # clone GoodJetsProducer
    GoodJetsForHadTau = process.GoodJets.clone(
        JetTag = JetTag,
        jetPtFilter = cms.double(0),
        SaveAllJets = cms.bool(True),
        ExcludeLepIsoTrackPhotons = cms.bool(False),
    )
    setattr(process,"GoodJetsForHadTau"+suff,GoodJetsForHadTau)
    theSequence += getattr(process,"GoodJetsForHadTau"+suff)
    GoodJetsTag = cms.InputTag("GoodJetsForHadTau"+suff)
    
    process.TreeMaker2.VectorRecoCand.extend(['GoodJetsForHadTau'+suff+'(softJets'+suff+')'])
    process.TreeMaker2.VectorBool.extend(['GoodJetsForHadTau'+suff+':JetIDMask(softJets'+suff+'_ID)'])
    
    if storeProperties>0:
        # make jet properties producer
        from TreeMaker.Utils.jetproperties_cfi import jetproperties
        JetsProperties = jetproperties.clone(
            JetTag       = GoodJetsTag,
            properties   = cms.vstring("jecFactor","jecUnc")
        )
        # provide extra info where necessary
        JetsProperties.jecUnc = cms.vstring("jecUncHadTau")
        setattr(process,"HadTauJetsProperties"+suff,JetsProperties)
        theSequence += getattr(process,"HadTauJetsProperties"+suff)
        process.TreeMaker2.VectorDouble.extend(['HadTauJetsProperties:jecFactor(softJets'+suff+'_jecFactor)','HadTauJetsProperties:jecUnc(softJets'+suff+'_jecUnc)'])
    
    return process
def neutronBG(process):

  # common fragment allowing to simulate neutron background in muon system

  if hasattr(process,'g4SimHits'):
  # time window 10 second
    TimeCut = cms.double(10000000000.0)
    process.common_maximum_time.MaxTrackTime = TimeCut
    process.common_maximum_time.DeadRegions = cms.vstring()
    # Physics List XS
    process.g4SimHits.Physics.type = cms.string('SimG4Core/Physics/FTFP_BERT_XS_EML')
    process.g4SimHits.Physics.CutsOnProton  = cms.untracked.bool(False)
    process.g4SimHits.Physics.FlagFluo    = cms.bool(True)
    process.g4SimHits.Physics.ThermalNeutrons = cms.untracked.bool(False)
    # Eta cut
    process.g4SimHits.Generator.MinEtaCut = cms.double(-7.0)
    process.g4SimHits.Generator.MaxEtaCut = cms.double(7.0)
    # stacking action
    process.g4SimHits.StackingAction.MaxTrackTime = TimeCut
    process.g4SimHits.StackingAction.DeadRegions = cms.vstring()
    process.g4SimHits.StackingAction.GammaThreshold = cms.double(0.0)
    # stepping action
    process.g4SimHits.SteppingAction.MaxTrackTime = TimeCut
    process.g4SimHits.SteppingAction.DeadRegions = cms.vstring()
    # Russian roulette disabled
    process.g4SimHits.StackingAction.RusRoGammaEnergyLimit = cms.double(0.0)
    process.g4SimHits.StackingAction.RusRoNeutronEnergyLimit = cms.double(0.0)
    # Calorimeter hits
    process.g4SimHits.CaloSD.TmaxHit = TimeCut
    process.g4SimHits.CaloSD.TmaxHits = cms.vdouble(10000000000,10000000000,10000000000,10000000000,10000000000)
    # full simulation of HF 
    process.g4SimHits.HCalSD.UseShowerLibrary = cms.bool(False)
    process.g4SimHits.HFShower.UseShowerLibrary = cms.bool(False)

    return(process)
Exemple #20
0
def setup_jets_(process, isData, bTagDiscriminators):
    from JMEAnalysis.JetToolbox.jetToolbox_cff import jetToolbox
    jetToolbox(process, 'ak4', 'ak4CHSJetSequence', 'out', PUMethod='CHS', runOnMC=not isData, miniAOD=True, addPUJetID=False, bTagDiscriminators=bTagDiscriminators + ['pfSimpleSecondaryVertexHighEffBJetTags'])
    process.softPFElectronsTagInfosAK4PFCHS.electrons = cms.InputTag('slimmedElectrons')
    process.softPFMuonsTagInfosAK4PFCHS.muons = cms.InputTag('slimmedMuons')

    # b-tagging information. From
    # https://github.com/cms-sw/cmssw/blob/CMSSW_7_4_X/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py#L130
    process.patJetsAK4PFCHS.userData.userFunctions = cms.vstring(
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.M):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).numberOfSourceCandidatePtrs):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").flightDistance(0).value):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").flightDistance(0).significance):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.x):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.y):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).p4.z):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).vertex.x):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).vertex.y):(0)',
            '?(tagInfoCandSecondaryVertex("pfSecondaryVertex").nVertices()>0)?(tagInfoCandSecondaryVertex("pfSecondaryVertex").secondaryVertex(0).vertex.z):(0)',
            )
    process.patJetsAK4PFCHS.userData.userFunctionLabels = cms.vstring('vtxMass','vtxNtracks','vtx3DVal','vtx3DSig','vtxPx','vtxPy','vtxPz','vtxPosX','vtxPosY','vtxPosZ')
    process.patJetsAK4PFCHS.tagInfoSources = cms.VInputTag(cms.InputTag("pfSecondaryVertexTagInfosAK4PFCHS"))
    process.patJetsAK4PFCHS.addTagInfos = cms.bool(True)

    # Pile-up jet id
    process.load('RecoJets.JetProducers.PileupJetID_cfi')
    process.pileupJetId.applyJec = False
    process.pileupJetId.vertexes = cms.InputTag('offlineSlimmedPrimaryVertices')
    process.patJetsAK4PFCHS.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
Exemple #21
0
def getUEParameters(ueName='CUEP8M2T4',pdfSet='NNPDF30_lo_as_0130'):
    if 'AZ' in ueName:
        ueParameters = cms.vstring( 'Tune:pp 17',
                                    'Tune:ee 3',
                                    'PDF:pSet=LHAPDF6:%s'%pdfSet )
    if 'CUETP8M1' in ueName:
        ueParameters = cms.vstring( 'Tune:pp 14',
                                    'Tune:ee 7',
                                    'MultipartonInteractions:pT0Ref=2.4024',
                                    'MultipartonInteractions:ecmPow=0.25208',
                                    'MultipartonInteractions:expPow=1.6',
                                    'PDF:pSet=LHAPDF6:%s'%pdfSet )

    if 'CUEP8M2T4' in ueName:
        if 'down' in ueName:
            ueParameters = cms.vstring( 'Tune:pp 14',
                                        'Tune:ee 7',
                                        'MultipartonInteractions:ecmPow=0.25208',
                                        'SpaceShower:alphaSvalue=0.1108',
                                        'PDF:pSet=LHAPDF6:%s'%pdfSet,
                                        'MultipartonInteractions:pT0Ref=2.268694e+00',
                                        'MultipartonInteractions:expPow=1.561995e+00',
                                        'ColourReconnection:range=8.714042e+00',
                                        )
        elif 'up' in ueName:
            ueParameters = cms.vstring( 'Tune:pp 14',
                                        'Tune:ee 7',
                                        'MultipartonInteractions:ecmPow=0.25208',
                                        'SpaceShower:alphaSvalue=0.1108',
                                        'PDF:pSet=LHAPDF6:%s'%pdfSet,
                                        'MultipartonInteractions:pT0Ref=2.127913e+00',
                                        'MultipartonInteractions:expPow=1.710694e+00',
                                        'ColourReconnection:range=6.500048e+00', 
                                        )
        else:
            ueParameters = cms.vstring( 'Tune:pp 14',
                                        'Tune:ee 7',
                                        'MultipartonInteractions:ecmPow=0.25208',
                                        'SpaceShower:alphaSvalue=0.1108',
                                        'PDF:pSet=LHAPDF6:%s'%pdfSet,
                                        'MultipartonInteractions:pT0Ref=2.197139e+00',
                                        'MultipartonInteractions:expPow=1.608572e+00',
                                        'ColourReconnection:range=6.593269e+00',
                                        )

    if 'FSRup'   in ueName: ueParameters.extend( ['TimeShower:renormMultFac   = 4.0'] )
    if 'FSRdown' in ueName: ueParameters.extend( ['TimeShower:renormMultFac   = 0.25'] )
    if 'ISRup'   in ueName: ueParameters.extend( ['SpaceShower:renormMultFac  = 4.0'] )
    if 'ISRdown' in ueName: ueParameters.extend( ['SpaceShower:renormMultFac  = 0.25'] )
    if 'primordialKToff' in ueName : ueParameters.extend( ['BeamRemnants:primordialKT = off'] )
    for param in ['SpaceShower:pT0Ref','SpaceShower:pTmin']:
        if not param in ueName : continue
        newVal=re.findall( "\d+\.\d+", re.search(r'%s=(.*)'%param, ueName).groups()[0] )[0]
        print 'Setting',param,'to',newVal
        ueParameters.extend( ['%s=%s'%(param,newVal) ] )
    


    return ueParameters
def get(todo):
    defs = {}
    defs["ak5GenJetView"]= cms.PSet(   
        miniView = cms.string("GenJetView"),
        branchPrefix = cms.untracked.string("ak5GenJets"),
        maxEta = cms.double(7.0),
        minPt = cms.double(1.0),
        genJets = cms.InputTag("ak5GenJets"),
    )

    defs["ak5CastorJetView"]= cms.PSet(   
        miniView = cms.string("CastorJetView"),
        branchPrefix = cms.untracked.string("ak5CastorJets"),
        minCastorJetEnergy = cms.double(50.),
        jetRadius = cms.double(0.5)
    )

    defs["ak7CastorJetView"]= cms.PSet(   
        miniView = cms.string("CastorJetView"),
        branchPrefix = cms.untracked.string("ak7CastorJets"),
        minCastorJetEnergy = cms.double(50.),
        jetRadius = cms.double(0.7)
    )

    defs["VerticesView"]= cms.PSet(   
        miniView = cms.string("VerticesView"),
        branchPrefix = cms.untracked.string("Vtx"),
        src = cms.InputTag("offlinePrimaryVertices"),
    )

    defs["CastorRecHitView"]= cms.PSet(   
        miniView = cms.string("CastorRecHitView"),
        branchPrefix = cms.untracked.string("CastorRecHit"),
    )   

    defs["JetViewPFAK4CHS"]  = cms.PSet(
        miniView = cms.string("JetView"),
        storeageVersion = cms.untracked.int32(0),
        disableJetID = cms.bool(True),
        optionalCaloJets4ID = cms.InputTag(""),#ak5CaloJets","","RECO"),
        optionalCaloID4ID  = cms.InputTag(""),#ak5JetID"),
        branchPrefix = cms.untracked.string("PFAK4CHS"),
        maxEta = cms.double(5.2),
        minPt = cms.double(1),
        maxnum = cms.int32(3),
        input = cms.InputTag("selectedPatJetsAK4PFCHSCopy"),
        variations= cms.vstring(""),
        jerFactors = cms.vstring(  # PF10
                "5.5 1 0.007 0.07 0.072"),
    )

    ret = {}
    for t in todo:
        if t not in defs:
            raise Exception("miniView def not known "+t)

        ret[t] = defs[t]
    return ret
def get(todo):
    defs = {}

    defs["ak5CastorJetView"]= cms.PSet(   
        miniView = cms.string("CastorJetView"),
        branchPrefix = cms.untracked.string("ak5CastorJets"),
        minCastorJetEnergy = cms.double(100.),
        jetRadius = cms.double(0.5)
    )

    defs["ak7CastorJetView"]= cms.PSet(   
        miniView = cms.string("CastorJetView"),
        branchPrefix = cms.untracked.string("ak7CastorJets"),
        minCastorJetEnergy = cms.double(100.),
        jetRadius = cms.double(0.7)
    )

    defs["CastorRecHitViewFull"]= cms.PSet(   
        miniView = cms.string("CastorRecHitView"),
        branchPrefix = cms.untracked.string("CastorRecHit"),
        onlyGoodRecHits = cms.bool(False),
        writeSaturationInfo = cms.bool(True),        
    )   

    defs["CastorRecHitViewBasic"]= cms.PSet(   
        miniView = cms.string("CastorRecHitView"),
        branchPrefix = cms.untracked.string("CastorRecHit"),
        onlyGoodRecHits = cms.bool(True),
        writeSaturationInfo = cms.bool(False),        
    )   
    defs["TriggerResultsView"] = cms.PSet(
         miniView = cms.string("TriggerResultsView"),
         branchPrefix = cms.untracked.string("trg"),
         process = cms.string("HLT"), # usually HLT
         triggers = cms.vstring("randoms","noBPTX","zeroBias"),
         randoms =  cms.vstring("HLT_Random_v2*"),
         noBPTX =  cms.vstring("HLT_L1Tech7_NoBPTX_v1*"),
         zeroBias =  cms.vstring("HLT_ZeroBias_part0_v1*"),
     )
    defs["VerticesView"]= cms.PSet(
        miniView = cms.string("VerticesView"),
        branchPrefix = cms.untracked.string("Vtx"),
        src = cms.InputTag("offlinePrimaryVertices"),
    )

    defs["CastorTowerView"]  = cms.PSet(
        miniView = cms.string("CastorTowerView"),
        branchPrefix = cms.untracked.string("CastorTower"),
        inputcoll = cms.InputTag("CastorTowerReco")
    )

    ret = {}
    for t in todo:
        if t not in defs:
            raise Exception("miniView def not known "+t)

        ret[t] = defs[t]
    return ret
def buildQCDdiJetTauSequence(
    process, 
    collectionName = [ "patTaus", "" ],
    jetCollectionName = "patJets",
    patTauProducerPrototype = None,
    patTauCleanerPrototype = None,
    triggerMatcherProtoType = None,
    addGenInfo = False,
    applyTauJEC = False,
    applyTauVertexMatch = True):
    '''
    blah
    '''

    # produce collection of basic pat::Taus
    # matched to generator level particles and jets
    # and trigger primitives embedded
    retVal_tau = buildTauSequence(
        process, 
        collectionName = collectionName,
        jetCollectionName = jetCollectionName,
        patTauProducerPrototype = patTauProducerPrototype,
        patTauCleanerPrototype = patTauCleanerPrototype,
        triggerMatcherProtoType = triggerMatcherProtoType,
        addGenInfo = addGenInfo,
        applyTauJEC = applyTauJEC,
        applyTauVertexMatch = applyTauVertexMatch
    )

    outputSequence = retVal_tau["sequence"]

    # produce final collection of pat::Taus with
    # flags embedded to:
    #  o indicate index of tau-jet candidate in Pt-sorted collection of jets
    #  o indicate whether tau-jet candidate is tag/probe
    patTauDijetTagAndProbe = cms.EDProducer("TauIdTagAndProbeProducer",
        source = cms.InputTag(retVal_tau["collection"]),
        triggerPaths = cms.PSet(
            HLT_Jet30  = cms.vstring('pt >  30.0'),
            HLT_Jet60  = cms.vstring('pt >  60.0'),
            HLT_Jet80  = cms.vstring('pt >  80.0'),
            HLT_Jet110 = cms.vstring('pt > 110.0'),
            HLT_Jet150 = cms.vstring('pt > 150.0')
        )
    )
    patTauDijetTagAndProbeName = collectionName[0] + "DijetTagAndProbe" + collectionName[1]
    setattr(process, patTauDijetTagAndProbeName, patTauDijetTagAndProbe)
    outputSequence += getattr(process, patTauDijetTagAndProbeName)

    # return full sequence for production of basic tau collection,
    # generator level particle and jet matches, trigger matches,
    # Pt-sorting and tag/probe flags;
    # together with name of "cleaned" tau collection
    # to be used as InputTag for further processing
    retVal = {}
    retVal["sequence"] = outputSequence
    retVal["collection"] = patTauDijetTagAndProbeName
    return retVal
def addVariables(module):

    Variables = cms.PSet(
        mass = cms.vstring("Tag-Probe Mass", "60.0", "120.0", "GeV/c^{2}"),
        pt = cms.vstring("Probe p_{T}", "0", "100", "GeV/c"),
        abseta = cms.vstring("Probe |#eta|", "-2.5", "2.5", "")
        )

    module.Variables = Variables
def ConfigureTPAnalyzer (Analyzer, fileName, pred,binScheme, tree= "fitter_tree"):
    """
    This one configures the TnP Analyzer
    """
    Analyzer.InputFileNames = cms.vstring("/hdfs/store/user/kaur/"+fileName+".root")
    print "/hdfs/store/user/kaur/"+fileName+".root"
    Analyzer.Categories.probe_passingGsf=cms.vstring((pred,"dummy[pass=1,fail=0]"))
    Analyzer.Efficiencies.binning =  binScheme
    Analyzer.Efficiencies.binning.EfficiencyCategoryAndState=cms.vstring(pred, "pass")
    Analyzer.InputTreeName = cms.string(tree)
Exemple #27
0
def makeTnPFitter(process, suffix, category):
    fitter = cms.EDAnalyzer("TagProbeFitTreeAnalyzer",
        #InputFileNames = cms.vstring("ntuple/0j/tnpTree_%s.root" % mode),
        InputFileNames = cms.vstring("ntuple/ntuple_%s.root" % mode),
        InputDirectoryName = cms.string("tnp"+suffix),
        InputTreeName = cms.string("fitter_tree"),
        OutputFileName = cms.string("result/unmerged/result_%s_%s_%s.root" % (suffix, category, mode)),
        NumCPU = cms.uint32(1),
        SaveWorkspace = cms.bool(False),
        floatShapeParameters = cms.bool(True),
        WeightVariable = cms.string("weight"),
        Variables = cms.PSet(
            mass = cms.vstring("Tag-Probe mass", "60.0", "120.0", "GeV/c^{2}"),
            pt = cms.vstring("Probe p_{T}", "0", "1000", "GeV/c"),
            abseta = cms.vstring("Probe |#eta|", "0", "2.5", ""),
            event_nPV = cms.vstring("Number of vertex", "0", "30", ""),
            event_nJet = cms.vstring("Jet multiplicity", "0", "5", ""),
            pair_dz = cms.vstring("#Delta z", "0", "0.3", "cm"),
            weight = cms.vstring("Weight", "0.0", "2.0", ""),
        ),
        Categories = cms.PSet(),
        PDFs = basicPDFs,
        binnedFit = cms.bool(True),
        binsForFit = cms.uint32(100),
        Quiet = cms.untracked.bool(True),
    )

    setattr(fitter, 'Efficiencies', tnpEffPSet(category))
    setattr(fitter.Categories, category, cms.vstring(category, "dummy[pass=1,fail=0]"))

    setattr(process, 'fit'+suffix, fitter)
    process.p += getattr(process, 'fit'+suffix)
def _generate_RS1GG(step, evt_type, energy, evtnumber):
    """
    Here the settings for the RS1 graviton into gamma gamma.
    """
      
    func_id=mod_id+"["+sys._getframe().f_code.co_name+"]"
    common.log( func_id+" Entering... ")         
    
    # Build the process source
    generator = cms.EDFilter('Pythia6GeneratorFilter', 
                      pythiaPylistVerbosity=cms.untracked.int32(0),
                      pythiaHepMCVerbosity=cms.untracked.bool(False),
                      maxEventsToPrint = cms.untracked.int32(0), 
                      filterEfficiency = cms.untracked.double(1),    
                      PythiaParameters = cms.PSet\
                               (parameterSets = cms.vstring('PythiaUESettings','processParameters'),
                                PythiaUESettings=user_pythia_ue_settings(),
                                processParameters=\
                                    cms.vstring('MSEL=0   ', 
                                                'MSUB(391)   =1   ', 
                                                'MSUB(392)   =1   ', 
                                                'PMAS(347,1) = %s ' %energy,# ! minv ', 
                                                'PARP(50)    = 0.54 ',# ! 0.54 == c=0.1', 
                                                'MDME(4158,1)=0   ',
                                                'MDME(4159,1)=0   ',
                                                'MDME(4160,1)=0   ',
                                                'MDME(4161,1)=0   ',
                                                'MDME(4162,1)=0   ',
                                                'MDME(4163,1)=0   ',
                                                'MDME(4164,1)=0   ',
                                                'MDME(4165,1)=0   ',
                                                'MDME(4166,1)=0   ',
                                                'MDME(4167,1)=0   ',
                                                'MDME(4168,1)=0   ',
                                                'MDME(4169,1)=0   ',
                                                'MDME(4170,1)=0   ',
                                                'MDME(4170,1)=0   ',
                                                'MDME(4171,1)=0   ',
                                                'MDME(4172,1)=0   ',
                                                'MDME(4173,1)=0   ',
                                                'MDME(4174,1)=0   ',
                                                'MDME(4175,1)=1   ',#! gamma gamma ', 
                                                'MDME(4176,1)=0   ', 
                                                'MDME(4177,1)=0   ', 
                                                'MDME(4178,1)=0   ', 
                                                'CKIN(3)=20.      ',#! minimum pt hat for hard interactions', 
                                                'CKIN(4)=-1.      '#! maximum pt hat for hard interactions'
                                               )
                               )
                     )

    common.log(func_id+" Returning Generator...")
     
    return generator                     
def ConfigureTPAnalyzer (Analyzer, fileName, pred,binScheme, tree= "fitter_tree"):
    """
    This one configures the TnP Analyzer
    """
#    Analyzer.InputFileNames = cms.vstring("/hdfs/store/user/anil79/TnPTreeElec_DoubleElectronRun2012A-13Jul2012-v1_Jan8-fortests2012AB/1/fortests2012AB-FE1CBE0B-03DA-E111-A2AD-00266CFAE20C.root")
    Analyzer.InputFileNames = cms.vstring("/hdfs/store/user/kaur/"+fileName+".root")
    print "/hdfs/store/user/kaur/"+fileName+".root"
    Analyzer.Categories.probe_isWPMedium=cms.vstring((pred,"dummy[pass=1,fail=0]"))
    Analyzer.Efficiencies.binning =  binScheme
    Analyzer.Efficiencies.binning.EfficiencyCategoryAndState=cms.vstring(pred, "pass")
    Analyzer.InputTreeName = cms.string(tree)
def addCategories(module):
    
    Categories = cms.PSet(
        #mcTrue = cms.vstring("MC true", "dummy[true=1,false=0]"),
        tauAntiEMVA = cms.vstring("tau anti-E mva", "dummy[passed=1,fail=0]"),
        tauAntiE2D = cms.vstring("tau anti-E 2D", "dummy[passed=1,fail=0]"),
        #tauAntiECrackRem = cms.vstring("tau anti-E crack removal", "dummy[passed=1,fail=0]"),
        #tauAntiEMVAandCrackRem = cms.vstring("tau anti-E mva AND crack rem", "dummy[passed=1,fail=0]"),
        #tauAntiE2DandCrackRem = cms.vstring("tau anti-E mva AND crack removal", "dummy[passed=1,fail=0]"),
        )

    module.Categories = Categories
process.load('RecoLocalCalo.Castor.Castor_cff') #castor tower and jet reconstruction

from EventFilter.CastorRawToDigi.CastorRawToDigi_cff import *
process.castorDigis = castorDigis.clone()

from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
process.castorMonitor = DQMEDAnalyzer("CastorMonitorModule",
                           ### GLOBAL VARIABLES
   debug = cms.untracked.int32(0), #(=0 - no messages)
                           # Turn on/off timing diagnostic
                           showTiming          = cms.untracked.bool(False),

                           # Define Labels
     l1tStage2uGtSource = cms.InputTag("gtStage2Digis"),
     tagTriggerResults   = cms.InputTag('TriggerResults','','HLT'),
    HltPaths  = cms.vstring("HLT_ZeroBias","HLT_Random"),

                           digiLabel            = cms.InputTag("castorDigis"),
                           rawLabel             = cms.InputTag("rawDataCollector"),
                           unpackerReportLabel  = cms.InputTag("castorDigis"),
                           CastorRecHitLabel    = cms.InputTag("castorreco"),
                           CastorTowerLabel     = cms.InputTag("CastorTowerReco"),
                           CastorBasicJetsLabel = cms.InputTag("ak7CastorJets"),
                           CastorJetIDLabel     = cms.InputTag("ak7CastorJetID"),

                           DataIntMonitor= cms.untracked.bool(True),
                           TowerJetMonitor= cms.untracked.bool(True),

                           DigiMonitor = cms.untracked.bool(True),

                           RecHitMonitor = cms.untracked.bool(True),
import FWCore.ParameterSet.Config as cms

from Configuration.Generator.HerwigppDefaults_cfi import *

generator = cms.EDFilter(
    "ThePEGGeneratorFilter",
    herwigDefaultsBlock,
    configFiles = cms.vstring(),

    parameterSets = cms.vstring(
    'cm8TeV',
    'powhegNewDefaults',
    'HbbZllParameters',
    'basicSetup',
    'setParticlesStableForDetector',
    ),

   powhegNewDefaults = cms.vstring(
    '#  Need to use an NLO PDF',
    '#  and strong coupling',
    'cp /Herwig/Partons/MRST-NLO /Herwig/Partons/cmsPDFSet',
    'create Herwig::O2AlphaS O2AlphaS',
    'set /Herwig/Generators/LHCGenerator:StandardModelParameters:QCD/RunningAlphaS O2AlphaS',
    '#  Setup the POWHEG shower',
    'cd /Herwig/Shower',
    'set Evolver:HardEmissionMode POWHEG',

    '# higgs + W (N.B. if considering all W decay modes useful to set )',
    '#           (jet pT cut to zero so no cut on W decay products    )',
    '# insert SimpleQCD:MatrixElements[0] PowhegMEPP2WH',
    '# set /Herwig/Cuts/JetKtCut:MinKT 0.0*GeV',
import FWCore.ParameterSet.Config as cms

input_files = cms.vstring(
    "root://eostotem.cern.ch//eos/totem/data/ctpps/reconstruction/2017/preTS2_alignment_data/version1/fill6191_xangle150_ZeroBias.root"
)
from Configuration.Generator.Pythia8CommonSettings_cfi import *
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *

source = cms.Source("EmptySource")
generator = cms.EDFilter("Pythia8GeneratorFilter",
                         pythiaHepMCVerbosity=cms.untracked.bool(False),
                         maxEventsToPrint=cms.untracked.int32(0),
                         pythiaPylistVerbosity=cms.untracked.int32(0),
                         filterEfficiency=cms.untracked.double(1.0),
                         comEnergy=cms.double(8000.0),
                         PythiaParameters=cms.PSet(
                             pythia8CommonSettingsBlock,
                             pythia8CUEP8M1SettingsBlock,
                             processParameters=cms.vstring(
                                 'WeakSingleBoson:ffbar2gmZ = on',
                                 '23:onMode = off',
                                 '23:onIfAny = 13',
                                 'PhaseSpace:pTHatMin = 40.',
                             ),
                             parameterSets=cms.vstring(
                                 'pythia8CommonSettings',
                                 'pythia8CUEP8M1Settings',
                                 'processParameters',
                             )))
mumugenfilter = cms.EDFilter("MCParticlePairFilter",
                             Status=cms.untracked.vint32(1, 1),
                             MinPt=cms.untracked.vdouble(2.5, 2.5),
                             MaxEta=cms.untracked.vdouble(2.5, 2.5),
                             MinEta=cms.untracked.vdouble(-2.5, -2.5),
                             ParticleCharge=cms.untracked.int32(-1),
                             ParticleID1=cms.untracked.vint32(13),
                             ParticleID2=cms.untracked.vint32(13))
Exemple #35
0
    Verbosity=cms.untracked.int32(0),  ## set to 1 (or greater)  for printouts
    psethack=cms.string('single neutron E 100'),
    AddAntiParticle=cms.bool(True),
    firstRun=cms.untracked.uint32(1))

process.ProductionFilterSequence = cms.Sequence(process.generator)

# Output definition
process.output = cms.OutputModule(
    "PoolOutputModule",
    outputCommands=process.FEVTDEBUGEventContent.outputCommands,
    fileName=cms.untracked.string('simevent.root'),
    dataset=cms.untracked.PSet(dataTier=cms.untracked.string('GEN-SIM'),
                               filterName=cms.untracked.string('')),
    SelectEvents=cms.untracked.PSet(
        SelectEvents=cms.vstring('generation_step')))

# Special settings
process.g4SimHits.UseMagneticField = cms.bool(False)
process.g4SimHits.Physics.DefaultCutValue = cms.double(10.)
process.g4SimHits.Generator.MinEtaCut = cms.double(-9.0)
process.g4SimHits.Generator.MaxEtaCut = cms.double(9.0)
process.g4SimHits.Watchers = cms.VPSet(
    cms.PSet(type=cms.string('ZdcTestAnalysis'),
             ZdcTestAnalysis=cms.PSet(
                 Verbosity=cms.int32(0),
                 StepNtupleFlag=cms.int32(0),
                 EventNtupleFlag=cms.int32(1),
                 StepNtupleFileName=cms.string('stepNtuple.root'),
                 EventNtupleFileName=cms.string('eventNtuple.root'))))
process.g4SimHits.ZdcSD.UseShowerLibrary = cms.bool(True)
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *

generator = cms.EDFilter("Pythia8GeneratorFilter",
                         comEnergy=cms.double(13000.0),
                         crossSection=cms.untracked.double(1.0),
                         filterEfficiency=cms.untracked.double(0.132),
                         maxEventsToPrint=cms.untracked.int32(0),
                         pythiaHepMCVerbosity=cms.untracked.bool(False),
                         pythiaPylistVerbosity=cms.untracked.int32(1),
                         PythiaParameters=cms.PSet(
                             pythia8CommonSettingsBlock,
                             pythia8CUEP8M1SettingsBlock,
                             processParameters=cms.vstring(
                                 'ExtraDimensionsG*:all = on',
                                 'ExtraDimensionsG*:kappaMG = 0.54',
                                 '5100039:m0 = 4500',
                                 '5100039:onMode = off',
                                 '5100039:onIfAny = 24',
                             ),
                             parameterSets=cms.vstring(
                                 'pythia8CommonSettings',
                                 'pythia8CUEP8M1Settings',
                                 'processParameters')))

llgenfilter = cms.EDFilter("MCMultiParticleFilter",
                           Status=cms.vint32(23, 23),
                           src=cms.InputTag('generator'),
                           ParticleID=cms.vint32(11, 13),
                           PtMin=cms.vdouble(0, 0),
                           NumRequired=cms.int32(1),
                           EtaMax=cms.vdouble(9999, 9999),
import FWCore.ParameterSet.Config as cms

# link to cards:
# https://github.com/cms-sw/genproductions/tree/master/bin/MadGraph5_aMCatNLO/cards/production/13TeV/exo_diboson/Spin-1/Wprime_WZ_WhadZlep/Wprime_WZ_WhadZlep_narrow_M4000


externalLHEProducer = cms.EDProducer("ExternalLHEProducer",
    args = cms.vstring('/cvmfs/cms.cern.ch/phys_generator/gridpacks/slc6_amd64_gcc481/13TeV/madgraph/V5_2.2.2/exo_diboson/Spin-1/Wprime_WZ_WhadZlep/narrow/v2/Wprime_WZ_WhadZlep_narrow_M4000_tarball.tar.xz'),
    nEvents = cms.untracked.uint32(5000),
    numberOfParameters = cms.uint32(1),
    outputFile = cms.string('cmsgrid_final.lhe'),
    scriptName = cms.FileInPath('GeneratorInterface/LHEInterface/data/run_generic_tarball_cvmfs.sh')
)
import FWCore.ParameterSet.Config as cms

from Configuration.Generator.PythiaUEZ2starSettings_cfi import *

source = cms.Source("EmptySource")
generator = cms.EDFilter("Pythia6GeneratorFilter", 
    pythiaHepMCVerbosity = cms.untracked.bool(False),
    maxEventsToPrint = cms.untracked.int32(0),
    pythiaPylistVerbosity = cms.untracked.int32(1),
    filterEfficiency = cms.untracked.double(1.0),
    comEnergy = cms.double(8000.0),
    crossSection = cms.untracked.double(0.0001259),
    PythiaParameters = cms.PSet(
        pythiaUESettingsBlock,
        processParameters = cms.vstring('PMAS(347,1)= 3500.         !mass of RS Graviton', 
            'PARP(50) = 0.54           ! 0.54 == c=0.1 (k/M_PL=0.1)', 
            'MSEL=0                    !(D=1) to select between full user control (0, then use MSUB) and some preprogrammed alternative', 
            'MSUB(391)=1               ! q qbar -> G* ', 
            'MSUB(392)=1               ! g g -> G*', 
            '5000039:ALLOFF            ! Turn off all decays of G*',         
            '5000039:ONIFANY 1 2 3 4 5 21  !Turn on the deays u ubar, d dbar, s sbar, c cbar, b bar, g g'),
        parameterSets = cms.vstring('pythiaUESettings', 
            'processParameters')
    )
)

ProductionFilterSequence = cms.Sequence(generator) 

Exemple #39
0
from DQMOffline.Trigger.TopMonitor_cfi import hltTOPmonitoring

topEleJet_jet = hltTOPmonitoring.clone()
topEleJet_jet.FolderName = cms.string('HLT/TopHLTOffline/TopMonitor/EleJet/JetMonitor')
topEleJet_jet.nmuons = cms.uint32(0)
topEleJet_jet.nelectrons = cms.uint32(1)
topEleJet_jet.njets = cms.uint32(1)
topEleJet_jet.eleSelection = cms.string('pt>50 & abs(eta)<2.1 & (dr03TkSumPt+dr04EcalRecHitSumEt+dr04HcalTowerSumEt)/pt<0.1')
topEleJet_jet.jetSelection = cms.string('pt>30 & abs(eta)<2.4')
topEleJet_jet.histoPSet.eleEtaBinning = cms.vdouble(-2.1,-1.5,-0.9,-0.6,-0.3,-0.1,0,0.1,0.3,0.6,0.9,1.5,2.1)
topEleJet_jet.histoPSet.eleEtaBinning2D = cms.vdouble(-2.1,-1.5,-0.6,0,0.6,1.5,2.1)
topEleJet_jet.histoPSet.elePtBinning = cms.vdouble(0,50,60,80,120,200,400)
topEleJet_jet.histoPSet.elePtBinning2D = cms.vdouble(0,50,70,120,200,400)
topEleJet_jet.histoPSet.jetPtBinning = cms.vdouble(0,30,35,37.5,40,50,60,80,120,200,400)
topEleJet_jet.histoPSet.jetPtBinning2D = cms.vdouble(0,30,35,40,50,60,80,100,200,400)
topEleJet_jet.numGenericTriggerEventPSet.hltPaths = cms.vstring('HLT_Ele30_eta2p1_WPTight_Gsf_CentralPFJet35_EleCleaned_v*')
topEleJet_jet.denGenericTriggerEventPSet.hltPaths = cms.vstring('HLT_Ele35_WPTight_Gsf_v*',
                                                             'HLT_Ele38_WPTight_Gsf_v*',
                                                             'HLT_Ele40_WPTight_Gsf_v*',)

topEleJet_ele = hltTOPmonitoring.clone()
topEleJet_ele.FolderName = cms.string('HLT/TopHLTOffline/TopMonitor/EleJet/ElectronMonitor')
topEleJet_ele.nmuons = cms.uint32(0)
topEleJet_ele.nelectrons = cms.uint32(1)
topEleJet_ele.njets = cms.uint32(1)
topEleJet_ele.eleSelection = cms.string('pt>25 & abs(eta)<2.1 & (dr03TkSumPt+dr04EcalRecHitSumEt+dr04HcalTowerSumEt)/pt<0.1')
topEleJet_ele.jetSelection = cms.string('pt>50 & abs(eta)<2.4')
topEleJet_ele.histoPSet.eleEtaBinning = cms.vdouble(-2.1,-1.5,-0.9,-0.6,-0.3,-0.1,0,0.1,0.3,0.6,0.9,1.5,2.1)
topEleJet_ele.histoPSet.eleEtaBinning2D = cms.vdouble(-2.1,-1.5,-0.6,0,0.6,1.5,2.1)
topEleJet_ele.histoPSet.elePtBinning = cms.vdouble(0,25,30,32.5,35,40,45,50,60,80,120,200,400)
topEleJet_ele.histoPSet.elePtBinning2D = cms.vdouble(0,25,30,40,50,60,80,100,200,400)
 
 PythiaParameters = cms.PSet(
 pythiaUESettingsBlock,
 processParameters = cms.vstring(
 'PMAS(25,1)=150.0        !Higgs mass', 
 'MSEL=0                  !(D=1) to select between full user control (0, then use MSUB) and some preprogrammed alternative', 
 'MSUB(102)=0             !ggH', 
 'MSUB(123)=0             !ZZ fusion to H', 
 'MSUB(124)=0             !WW fusion to H', 
 'MSUB(24)=1              !ZH Higgsstrahlung', 
 'MDME(174,1)=1           !Z decay into d dbar', 
 'MDME(175,1)=1           !Z decay into u ubar', 
 'MDME(176,1)=1           !Z decay into s sbar', 
 'MDME(177,1)=1           !Z decay into c cbar', 
 'MDME(178,1)=1           !Z decay into b bbar', 
 'MDME(179,1)=1           !Z decay into t tbar', 
 'MDME(180,1)=-1          !Z decay into b* b*bar',
 'MDME(181,1)=-1          !Z decay into t* t*bar',
 'MDME(182,1)=0           !Z decay into e- e+', 
 'MDME(183,1)=0           !Z decay into nu_e nu_ebar', 
 'MDME(184,1)=0           !Z decay into mu- mu+', 
 'MDME(185,1)=0           !Z decay into nu_mu nu_mubar', 
 'MDME(186,1)=0           !Z decay into tau- tau+', 
 'MDME(187,1)=0           !Z decay into nu_tau nu_taubar', 
 'MDME(188,1)=-1          !Z decay into tau* tau*bar', 
 'MDME(189,1)=-1          !Z decay into nu_tau* nu_tau*bar', 
 'MDCY(25,1)=0            !All Higgs decays switched off',
 ),
 parameterSets = cms.vstring(
 'pythiaUESettings',
 'processParameters',
Exemple #41
0
generator = cms.EDFilter(
    "Pythia6GeneratorFilter",
    pythiaHepMCVerbosity=cms.untracked.bool(False),
    maxEventsToPrint=cms.untracked.int32(0),
    pythiaPylistVerbosity=cms.untracked.int32(1),
    filterEfficiency=cms.untracked.double(1.),
    crossSection=cms.untracked.double(0.2588),
    comEnergy=cms.double(8000.0),
    PythiaParameters=cms.PSet(
        pythiaUESettingsBlock,
        processParameters=cms.vstring(
            'MSEL        = 0    !User defined processes',
            'MSUB(142)   = 1    !Wprime  production',
            'PMAS(34,1)  = 1300.!mass of Wprime',
            'MDME(311,1) = 0    !W\' decay into dbar u',
            'MDME(312,1) = 0    !W\' decay into dbar c',
            'MDME(313,1) = 0    !W\' decay into dbar t',
            'MDME(315,1) = 0    !W\' decay into sbar u',
            'MDME(316,1) = 0    !W\' decay into sbar c',
            'MDME(317,1) = 0    !W\' decay into sbar t',
            'MDME(319,1) = 0    !W\' decay into bbar u',
            'MDME(320,1) = 0    !W\' decay into bbar c',
            'MDME(321,1) = 0    !W\' decay into bbar t',
            'MDME(327,1) = 0    !W\' decay into e+ nu_e',
            'MDME(328,1) = 1    !W\' decay into mu+ nu_mu',
            'MDME(329,1) = 0    !W\' decay into tau+ nu_tau'),
        # This is a vector of ParameterSet names to be read, in this order
        parameterSets=cms.vstring('pythiaUESettings', 'processParameters')))

ProductionFilterSequence = cms.Sequence(generator)
import FWCore.ParameterSet.Config as cms
from Configuration.Generator.Pythia8CommonSettings_cfi import *
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *

generator = cms.EDFilter("Pythia8GeneratorFilter",
                         pythiaPylistVerbosity=cms.untracked.int32(0),
                         filterEfficiency=cms.untracked.double(1.0),
                         pythiaHepMCVerbosity=cms.untracked.bool(False),
                         comEnergy=cms.double(8000.0),
                         maxEventsToPrint=cms.untracked.int32(0),
                         PythiaParameters=cms.PSet(
                             pythia8CommonSettingsBlock,
                             pythia8CUEP8M1SettingsBlock,
                             processParameters=cms.vstring(
                                 'HardQCD:all = on',
                                 'PhaseSpace:pTHatMin = 20.',
                                 'PhaseSpace:pTHatMax = 30.'),
                             parameterSets=cms.vstring(
                                 'pythia8CommonSettings',
                                 'pythia8CUEP8M1Settings',
                                 'processParameters',
                             )))
Exemple #43
0
    maxEventsToPrint=cms.untracked.int32(0),
    PythiaParameters=cms.PSet(
        pythiaUESettingsBlock,
        processParameters=cms.vstring(
            'MSEL=0          ! User defined processes', 'MSUB(1)=1 !',
            'MSTP(43)    = 3   ! complete Z0/gamma* interference',
            'MSTP(1)=4 !fourth generation', 'CKIN(1)=%f !min sqrt(s hat)' %
            hipMass, 'CKIN(2)= -1  ! (no) max sqrt(s hat) (GeV)',
            'KCHG(17,1)=%i !charge of tauprime' % CHARGE,
            'PMAS(17,1)=%f !tauprime mass' % hipMass,
            'MDME(174,1) = 0   !Z decay into d dbar',
            'MDME(175,1) = 0   !Z decay into u ubar',
            'MDME(176,1) = 0   !Z decay into s sbar',
            'MDME(177,1) = 0   !Z decay into c cbar',
            'MDME(178,1) = 0   !Z decay into b bbar',
            'MDME(179,1) = 0   !Z decay into t tbar',
            'MDME(180,1) = 0   !Z decay into bprime bprimebar',
            'MDME(181,1) = 0   !Z decay into tprime tprimebar',
            'MDME(182,1) = 0   !Z decay into e- e+',
            'MDME(183,1) = 0   !Z decay into nu_e nu_ebar',
            'MDME(184,1) = 0   !Z decay into mu- mu+',
            'MDME(185,1) = 0   !Z decay into nu_mu nu_mubar',
            'MDME(186,1) = 0   !Z decay into tau- tau+',
            'MDME(187,1) = 0   !Z decay into nu_tau nu_taubar',
            'MDME(188,1) = 1   !Z decay into tauprime tauprimebar',
            'MDME(189,1) = 0   !Z decay into nu_tauprime nu_tauprimebar',
            'MDCY(17,1)=0    ! set tauprime stable',
            'MWID(17)=0      ! set tauprime width 0'),
        parameterSets=cms.vstring('pythiaUESettings', 'processParameters'),
    ))
    hemispheres=cms.InputTag('caloHemispheres'))

SUSY_HLT_Razor_PostVal_POSTPROCESSING = cms.EDAnalyzer(
    "DQMGenericClient",
    subDirs=cms.untracked.vstring(
        "HLT/SUSYBSM/HLT_RsqMR300_Rsq0p09_MR200",
        "HLT/SUSYBSM/HLT_RsqMR300_Rsq0p09_MR200_4jet",
        "HLT/SUSYBSM/HLT_Rsq0p36", "HLT/SUSYBSM/HLT_RsqMR270_Rsq0p09_MR200",
        "HLT/SUSYBSM/HLT_RsqMR270_Rsq0p09_MR200_4jet",
        "HLT/SUSYBSM/HLT_Rsq0p30", "HLT/SUSYBSM/HLT_RsqMR260_Rsq0p09_MR200",
        "HLT/SUSYBSM/HLT_RsqMR260_Rsq0p09_MR200_4jet",
        "HLT/SUSYBSM/HLT_RsqMR240_Rsq0p09_MR200",
        "HLT/SUSYBSM/HLT_RsqMR240_Rsq0p09_MR200_4jet",
        "HLT/SUSYBSM/HLT_Rsq0p25",
        "HLT/SUSYBSM/HLT_RsqMR240_Rsq0p09_MR200_Calo",
        "HLT/SUSYBSM/HLT_RsqMR240_Rsq0p09_MR200_4jet_Calo",
        "HLT/SUSYBSM/HLT_Rsq0p25_Calo",
        "HLT/SUSYBSM/HLT_Rsq0p02_MR300_TriPFJet80_60_40_DoublePFBTagCSV0p7_0p4_Mbb60_200",
        "HLT/SUSYBSM/HLT_Rsq0p02_MR300_TriPFJet80_60_40_DoublePFBTagCSV0p7_Mbb60_200"
    ),
    verbose=cms.untracked.uint32(2),  # Set to 2 for all messages
    resolution=cms.vstring(""),
    efficiency=cms.vstring(
        "mr_turnOn_eff 'M_{R} efficiency (R^{2} > 0.15); M_{R} (GeV); #epsilon' mr mr_denom",
        "mr_tight_turnOn_eff 'M_{R} efficiency (R^{2} > 0.25); M_{R} (GeV); #epsilon' mr_tight mr_tight_denom",
        "rsq_turnOn_eff 'R^{2} efficiency (M_{R} > 300); R^{2}; #epsilon' rsq rsq_denom",
        "rsq_tight_turnOn_eff 'R^{2} efficiency (M_{R} > 400); R^{2}; #epsilon' rsq_tight rsq_tight_denom",
        "rsq_loose_turnOn_eff 'R^{2} efficiency (M_{R} > 0); R^{2}; #epsilon' rsq_loose rsq_loose_denom",
        "mrRsq_turnOn_eff '2D efficiency; M_{R} (GeV); R^{2}; #epsilon' mrRsq mrRsq_denom"
    ))
import FWCore.ParameterSet.Config as cms
import os

from tthAnalysis.HiggsToTauTau.configs.recommendedMEtFilters_cfi import *
from tthAnalysis.HiggsToTauTau.configs.EvtYieldHistManager_cfi import *

process = cms.PSet()

process.fwliteInput = cms.PSet(fileNames=cms.vstring(),
                               maxEvents=cms.int32(-1),
                               outputEvery=cms.uint32(100000))

process.fwliteOutput = cms.PSet(fileName=cms.string(''))

process.analyze_hh_3l = cms.PSet(
    treeName=cms.string('Events'),
    process=cms.string(''),
    histogramDir=cms.string(''),
    era=cms.string(''),
    triggers_1e=cms.vstring(),
    use_triggers_1e=cms.bool(True),
    triggers_1mu=cms.vstring(),
    use_triggers_1mu=cms.bool(True),
    triggers_2e=cms.vstring(),
    use_triggers_2e=cms.bool(True),
    triggers_1e1mu=cms.vstring(),
    use_triggers_1e1mu=cms.bool(True),
    triggers_2mu=cms.vstring(),
    use_triggers_2mu=cms.bool(True),
    triggers_3e=cms.vstring(),
    use_triggers_3e=cms.bool(False),
import FWCore.ParameterSet.Config as cms

from Configuration.Generator.PyquenTuneZ2Settings_cff import *

hiSignal = cms.EDFilter(
    "PyquenGeneratorFilter",
    collisionParameters,
    qgpParameters,
    pyquenParameters,
    doQuench=cms.bool(False),
    doIsospin=cms.bool(True),
    bFixed=cms.double(0.0),  ## fixed impact param (fm); valid only if cflag_=0
    PythiaParameters=cms.PSet(
        pyquenPythiaDefaultBlock,
        parameterSets=cms.vstring('pythiaUESettings', 'ppJets', 'kinematics'),
        kinematics=cms.vstring(
            "CKIN(3)=80",  #min pthat
            "CKIN(4)=9999"  #max pthat
        )),
    cFlag=cms.int32(0),  ## centrality flag
    bMin=cms.double(0.0),  ## min impact param (fm); valid only if cflag_!=0
    bMax=cms.double(0.0)  ## max impact param (fm); valid only if cflag_!=0
)

hiSignal.embeddingMode = True

configurationMetadata = cms.untracked.PSet(annotation=cms.untracked.string(
    'PYTHIA (unquenched) dijets in NN (pt-hat > 80 GeV) at sqrt(s) = 2.76TeV'))

ProductionFilterSequence = cms.Sequence(hiSignal)
import FWCore.ParameterSet.Config as cms

from Configuration.Generator.HerwigppDefaults_cfi import *

generator = cms.EDFilter(
    "ThePEGGeneratorFilter",
    herwigDefaultsBlock,
    configFiles=cms.vstring(),
    parameterSets=cms.vstring(
        'cm7TeV',
        'powhegDefaults',
        'HbbZbbParameters',
        'basicSetup',
        'setParticlesStableForDetector',
    ),
    powhegDefaults=cms.vstring(
        '# Need to use an NLO PDF',
        'cp /Herwig/Partons/MRST-NLO /cmsPDFSet',
        '# and strong coupling',
        'create Herwig::O2AlphaS O2AlphaS',
        'set /Herwig/Generators/LHCGenerator:StandardModelParameters:QCD/RunningAlphaS O2AlphaS',
        '# Setup the POWHEG shower',
        'cd /Herwig/Shower',
        '# use the general recon for now',
        'set KinematicsReconstructor:ReconstructionOption General',
        '# create the Powheg evolver and use it instead of the default one',
        'create Herwig::PowhegEvolver PowhegEvolver HwPowhegShower.so',
        'set ShowerHandler:Evolver PowhegEvolver',
        'set PowhegEvolver:ShowerModel ShowerModel',
        'set PowhegEvolver:SplittingGenerator SplittingGenerator',
        'set PowhegEvolver:MECorrMode 0',
import FWCore.ParameterSet.Config as cms

from Configuration.Generator.PythiaUEZ2starSettings_cfi import *
generator = cms.EDFilter("Pythia6GeneratorFilter",
    pythiaHepMCVerbosity = cms.untracked.bool(False),
    maxEventsToPrint = cms.untracked.int32(0),
    pythiaPylistVerbosity = cms.untracked.int32(0),
    filterEfficiency = cms.untracked.double(1.0),
    comEnergy = cms.double(13000.0),
    PythiaParameters = cms.PSet(
        pythiaUESettingsBlock,
        processParameters = cms.vstring('MSEL=1               ! QCD hight pT processes', 
            'CKIN(3)=600.        ! minimum pt hat for hard interactions', 
            'CKIN(4)=800.        ! maximum pt hat for hard interactions'),
        # This is a vector of ParameterSet names to be read, in this order
        parameterSets = cms.vstring('pythiaUESettings', 
            'processParameters')
    )
)
Exemple #49
0
process = cms.Process("rawRECO")

process.source = cms.Source(
    "PoolSource",
    fileNames=cms.untracked.vstring(
        #'file:/eos/cms/store/data/Run2017B/AlCaLumiPixels/ALCARECO/AlCaPCCRandom-PromptReco-v1/000/297/411/00000/0AC6C13D-F259-E711-AB3A-02163E019E8E.root',
        'file:/eos/cms/store/data/Run2017E/AlCaLumiPixels/ALCARECO/AlCaPCCZeroBias-PromptReco-v1/000/303/832/00000/00C0E09B-99A4-E711-A481-02163E014661.root',
        'file:/eos/cms/store/data/Run2017E/AlCaLumiPixels/ALCARECO/AlCaPCCZeroBias-PromptReco-v1/000/303/832/00000/6C93C399-97A4-E711-8B70-02163E011A1C.root',
        'file:/eos/cms/store/data/Run2017E/AlCaLumiPixels/ALCARECO/AlCaPCCZeroBias-PromptReco-v1/000/303/832/00000/9EC76272-96A4-E711-85F1-02163E01A2E6.root',
        'file:/eos/cms/store/data/Run2017E/AlCaLumiPixels/ALCARECO/AlCaPCCZeroBias-PromptReco-v1/000/303/832/00000/DCF5DB86-92A4-E711-A1C4-02163E0124EE.root'
    ))
#Added process to select the appropriate events
process.OutALCARECOPromptCalibProdPCC = cms.PSet(
    SelectEvents=cms.untracked.PSet(
        SelectEvents=cms.vstring('pathALCARECOPromptCalibProdPCC')),
    outputCommands=cms.untracked.vstring('drop *', 'keep *_rawPCCProd_*_*'))

#Make sure that variables match in producer.cc and .h
process.rawPCCProd = cms.EDProducer(
    "RawPCCProducer",
    RawPCCProducerParameters=cms.PSet(
        #Mod factor to count lumi and the string to specify output
        inputPccLabel=cms.string("alcaPCCProducerZeroBias"),
        ProdInst=cms.string("alcaPCCZeroBias"),
        OutputValue=cms.untracked.string("Average"),
        outputProductName=cms.untracked.string("rawPCZeroBias"),
        #Below is a list of module IDs that will be ignored in calculation of luminosity
        ApplyCorrections=cms.untracked.bool(True),
        modVeto=cms.vint32()))
import FWCore.ParameterSet.Config as cms
import os

from tthAnalysis.HiggsToTauTau.configs.recommendedMEtFilters_cfi import *
from tthAnalysis.HiggsToTauTau.configs.EvtYieldHistManager_cfi import *

process = cms.PSet()

process.fwliteInput = cms.PSet(fileNames=cms.vstring(),
                               maxEvents=cms.int32(-1),
                               outputEvery=cms.uint32(100000))

process.fwliteOutput = cms.PSet(fileName=cms.string(''))

process.analyze_2lss_1tau = cms.PSet(
    treeName=cms.string('Events'),
    process=cms.string(''),
    histogramDir=cms.string(''),
    era=cms.string(''),
    triggers_1e=cms.vstring(),
    use_triggers_1e=cms.bool(True),
    triggers_2e=cms.vstring(),
    use_triggers_2e=cms.bool(True),
    triggers_1mu=cms.vstring(),
    use_triggers_1mu=cms.bool(True),
    triggers_2mu=cms.vstring(),
    use_triggers_2mu=cms.bool(True),
    triggers_1e1mu=cms.vstring(),
    use_triggers_1e1mu=cms.bool(True),
    apply_offline_e_trigger_cuts_1e=cms.bool(True),
    apply_offline_e_trigger_cuts_2e=cms.bool(True),
                                options.inputFiles))

# Production Info
process.configurationMetadata = cms.untracked.PSet(
    annotation=cms.untracked.string(
        'Configuration/GenProduction/python/Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_cff.py nevts:1'
    ),
    name=cms.untracked.string('Applications'),
    version=cms.untracked.string('$Revision: 1.19 $'))

# Output definition

process.RAWSIMoutput = cms.OutputModule(
    "PoolOutputModule",
    SelectEvents=cms.untracked.PSet(
        SelectEvents=cms.vstring('generation_step')),
    dataset=cms.untracked.PSet(dataTier=cms.untracked.string('GEN'),
                               filterName=cms.untracked.string('')),
    eventAutoFlushCompressedSize=cms.untracked.int32(5242880),
    fileName=cms.untracked.string(options.outputFile),
    outputCommands=process.RAWSIMEventContent.outputCommands,
    splitLevel=cms.untracked.int32(0))

# Additional output definition

# Other statements
process.genstepfilter.triggerConditions = cms.vstring("generation_step")
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:mc', '')

process.generator = cms.EDFilter(
generator = cms.EDFilter("Pythia8GeneratorFilter",
                  comEnergy = cms.double(13000.0),
                  crossSection = cms.untracked.double(1.0),
                  filterEfficiency = cms.untracked.double(1.0),
                  maxEventsToPrint = cms.untracked.int32(0),
                  pythiaHepMCVerbosity = cms.untracked.bool(False),
                  pythiaPylistVerbosity = cms.untracked.int32(0),
                  PythiaParameters = cms.PSet(
		        pythia8CommonSettingsBlock,
                        pythia8CP5SettingsBlock,
                        processParameters = cms.vstring(
                            'ExcitedFermion:bg2bStar = on',
                            '4000005:m0 = 1000.0',
                            '4000005:onMode = off',
                            '4000005:onIfMatch = 22 5',
                            'ExcitedFermion:Lambda = 1000.0',
                            'ExcitedFermion:coupFprime = 0.1',
                            'ExcitedFermion:coupF = 0.1',
                            'ExcitedFermion:coupFcol = 0.1'
                            ),
                        parameterSets = cms.vstring(
			    'pythia8CommonSettings',
                            'pythia8CP5Settings',
			    'processParameters',
			    )
                  )
)
ProductionFilterSequence = cms.Sequence(generator)


        processParameters = cms.vstring(
            'PMAS(25,1)=125.00D0    !mass of Higgs',
            'MSTP(1) = 4',
            'MSEL=7         ! User defined processes',
	    'MWID(7)=2',
            'MSTJ(1)=1       ! Fragmentation/hadronization on or off',
            'MSTP(61)=1      ! Parton showering on or off',
            'PMAS(5,1)=4.8   ! b quark mass', #from Spring11 4000040
            'PMAS(6,1)=172.5 ! t quark mass', #from Spring11 4000040
            'PMAS(7,1) = 900.0D0  ! bprime quarks mass',
            'PMAS(7,2) = 9.0D0',
            'PMAS(7,3) = 90.0D0',
 'VCKM(1,1) = 0.97414000D0',
 'VCKM(1,2) = 0.22450000D0',
 'VCKM(1,3) = 0.00420000D0',
 'VCKM(1,4) = 0.02500000D0',
 'VCKM(2,1) = 0.22560000D0',
 'VCKM(2,2) = 0.97170000D0',
 'VCKM(2,3) = 0.04109000D0',
 'VCKM(2,4) = 0.05700000D0',
 'VCKM(3,1) = 0.00100000D0',
 'VCKM(3,2) = 0.06200000D0',
 'VCKM(3,3) = 0.91000000D0',
 'VCKM(3,4) = 0.41000000D0',
 'VCKM(4,1) = 0.01300000D0',
 'VCKM(4,2) = 0.04000000D0',
 'VCKM(4,3) = 0.41000000D0',
 'VCKM(4,4) = 0.91000000D0',
            'MDME(56,1)=0     ! g b4', 
            'MDME(57,1)=0     ! gamma b4', 
            'MDME(58,1)=0     ! Z0 b', 
            'MDME(59,1)=0     ! W u', 
            'MDME(60,1)=0     ! W c', 
            'MDME(61,1)=0     ! W t', 
            'MDME(62,1)=0     ! W t4', 
            'KFDP(63,2)=5     ! defines H0 b', 
            'MDME(63,1)=1     ! h0 b4', 
            'MDME(64,1)=-1    ! H- c', 
            'MDME(65,1)=-1    ! H- t', 
            'BRAT(56)  = 0.0D0', 
            'BRAT(57)  = 0.0D0', 
            'BRAT(58)  = 0.0D0', 
            'BRAT(59)  = 0.0D0', 
            'BRAT(60)  = 0.0D0', 
            'BRAT(61)  = 0.0D0', 
            'BRAT(62)  = 0.0D0', 
            'BRAT(63)  = 1.0D0', 
            'BRAT(64)  = 0.0D0', 
            'BRAT(65)  = 0.0D0',
            'MDME(210,1)=1     !Higgs decay into dd', 
            'MDME(211,1)=1     !Higgs decay into uu', 
            'MDME(212,1)=1     !Higgs decay into ss', 
            'MDME(213,1)=1     !Higgs decay into cc', 
            'MDME(214,1)=1     !Higgs decay into bb', 
            'MDME(215,1)=1     !Higgs decay into tt', 
            'MDME(216,1)=1     !Higgs decay into', 
            'MDME(217,1)=1     !Higgs decay into Higgs decay', 
            'MDME(218,1)=1     !Higgs decay into e nu e', 
            'MDME(219,1)=1     !Higgs decay into mu nu mu', 
            'MDME(220,1)=1     !Higgs decay into tau nu tau', 
            'MDME(221,1)=1     !Higgs decay into Higgs decay', 
            'MDME(222,1)=1     !Higgs decay into g g', 
            'MDME(223,1)=1     !Higgs decay into gam gam', 
            'MDME(224,1)=1     !Higgs decay into gam Z', 
            'MDME(225,1)=1     !Higgs decay into Z Z', 
            'MDME(226,1)=1     !Higgs decay into W W', 
            'MDME(174,1)=1     !Z decay into d dbar',
            'MDME(175,1)=1     !Z decay into u ubar',
            'MDME(176,1)=1     !Z decay into s sbar',
            'MDME(177,1)=1     !Z decay into c cbar',
            'MDME(178,1)=1     !Z decay into b bbar',
            'MDME(179,1)=1     !Z decay into t tbar',
            'MDME(180,1)=-1    !Z decay into b4 b4bar',
            'MDME(181,1)=-1    !Z decay into t4 t4bar',
            'MDME(182,1)=1     !Z decay into e- e+',
            'MDME(183,1)=1     !Z decay into nu_e nu_ebar',
            'MDME(184,1)=1     !Z decay into mu- mu+',
            'MDME(185,1)=1     !Z decay into nu_mu nu_mubar',
            'MDME(186,1)=1     !Z decay into tau- tau+',
            'MDME(187,1)=1     !Z decay into nu_tau nu_taubar',
            'MDME(188,1)=-1    !Z decay into tau4 tau4bar',
            'MDME(189,1)=-1    !Z decay into nu_tau4 nu_tau4bar',
            'MDME(190,1)=1     !W decay into u dbar',
            'MDME(191,1)=1     !W decay into c dbar',
            'MDME(192,1)=1     !W decay into t dbar',
            'MDME(193,1)=-1    !W decay into t4 dbar',
            'MDME(194,1)=1     !W decay into u sbar',
            'MDME(195,1)=1     !W decay into c sbar',
            'MDME(196,1)=1     !W decay into t sbar',
            'MDME(197,1)=-1    !W decay into t4 sbar',
            'MDME(198,1)=1     !W decay into u bbar',
            'MDME(199,1)=1     !W decay into c bbar',
            'MDME(200,1)=1     !W decay into t bbar',
            'MDME(201,1)=-1    !W decay into t4 bbar',
            'MDME(202,1)=-1    !W decay into u b4bar',
            'MDME(203,1)=-1    !W decay into c b4bar',
            'MDME(204,1)=-1    !W decay into t b4bar',
            'MDME(205,1)=-1    !W decay into t4 b4bar',
            'MDME(206,1)=1     !W decay into e- nu_e',
            'MDME(207,1)=1     !W decay into mu nu_mu',
            'MDME(208,1)=1     !W decay into tau nu_tau',
            'MDME(209,1)=-1    !W decay into tau4 nu_tau4'),
        processParameters = cms.vstring(
            'MSTP(1) = 4',
            'MSEL=8          ! fourth generation (t4) fermions',
	    'MWID(8)=2',
            'MSTJ(1)=1       ! Fragmentation/hadronization on or off',
            'MSTP(61)=1      ! Parton showering on or off',
            'PMAS(5,1)=4.8   ! b quark mass', #from Spring11 4000040
            'PMAS(6,1)=172.5 ! t quark mass', #from Spring11 4000040
            'PMAS(8,1) = 800.0D0  ! tprime quarks mass',
            'PMAS(8,2) = 8.0D0',
            'PMAS(8,3) = 80.0D0',
            'VCKM(1,1) = 0.97414000D0',
            'VCKM(1,2) = 0.22450000D0',
            'VCKM(1,3) = 0.00420000D0',
            'VCKM(1,4) = 0.02500000D0',
            'VCKM(2,1) = 0.22560000D0',
            'VCKM(2,2) = 0.97170000D0',
            'VCKM(2,3) = 0.04109000D0',
            'VCKM(2,4) = 0.05700000D0',
            'VCKM(3,1) = 0.00100000D0',
            'VCKM(3,2) = 0.06200000D0',
            'VCKM(3,3) = 0.91000000D0',
            'VCKM(3,4) = 0.41000000D0',
            'VCKM(4,1) = 0.01300000D0',
            'VCKM(4,2) = 0.04000000D0',
            'VCKM(4,3) = 0.41000000D0',
            'VCKM(4,4) = 0.91000000D0',
            'KFDP(66,2)=6     ! defines g t4 (no check)', 
            'MDME(66,1)=2     ! g t4', 
            'KFDP(67,2)=6     ! defines gamma t ', 
            'MDME(67,1)=3     ! gamma t4', 
            'MDME(68,1)=0     ! Z0 t (2 : on for particle, off for anti-particle) ', 
            'MDME(69,1)=0     ! W d', 
            'MDME(70,1)=0     ! W s', 
            'MDME(71,1)=0     ! W b (3 : off for particle, on for particle) ', 
            'MDME(72,1)=0     ! W b4', 
            'MDME(73,1)=0     ! h0 t4', 
            'MDME(74,1)=-1    ! H+ b', 
            'MDME(75,1)=-1    ! H+ b4', 
            'BRAT(66)  = 1.0D0',
            'BRAT(67)  = 1.0D0',
            'BRAT(68)  = 0.0D0',
            'BRAT(69)  = 0.0D0',
            'BRAT(70)  = 0.0D0',
            'BRAT(71)  = 0.0D0',
            'BRAT(72)  = 0.0D0',
            'BRAT(73)  = 0.0D0',
            'BRAT(74)  = 0.0D0',
            'BRAT(75)  = 0.0D0',
            'MDME(174,1)=1     !Z decay into d dbar',
            'MDME(175,1)=1     !Z decay into u ubar',
            'MDME(176,1)=1     !Z decay into s sbar',
            'MDME(177,1)=1     !Z decay into c cbar',
            'MDME(178,1)=1     !Z decay into b bbar',
            'MDME(179,1)=1     !Z decay into t tbar',
            'MDME(180,1)=-1    !Z decay into b4 b4bar',
            'MDME(181,1)=-1    !Z decay into t4 t4bar',
            'MDME(182,1)=1     !Z decay into e- e+',
            'MDME(183,1)=1     !Z decay into nu_e nu_ebar',
            'MDME(184,1)=1     !Z decay into mu- mu+',
            'MDME(185,1)=1     !Z decay into nu_mu nu_mubar',
            'MDME(186,1)=1     !Z decay into tau- tau+',
            'MDME(187,1)=1     !Z decay into nu_tau nu_taubar',
            'MDME(188,1)=-1    !Z decay into tau4 tau4bar',
            'MDME(189,1)=-1    !Z decay into nu_tau4 nu_tau4bar',
            'MDME(190,1)=1     !W decay into u dbar',
            'MDME(191,1)=1     !W decay into c dbar',
            'MDME(192,1)=1     !W decay into t dbar',
            'MDME(193,1)=-1    !W decay into t4 dbar',
            'MDME(194,1)=1     !W decay into u sbar',
            'MDME(195,1)=1     !W decay into c sbar',
            'MDME(196,1)=1     !W decay into t sbar',
            'MDME(197,1)=-1    !W decay into t4 sbar',
            'MDME(198,1)=1     !W decay into u bbar',
            'MDME(199,1)=1     !W decay into c bbar',
            'MDME(200,1)=1     !W decay into t bbar',
            'MDME(201,1)=-1    !W decay into t4 bbar',
            'MDME(202,1)=-1    !W decay into u b4bar',
            'MDME(203,1)=-1    !W decay into c b4bar',
            'MDME(204,1)=-1    !W decay into t b4bar',
            'MDME(205,1)=-1    !W decay into t4 b4bar',
            'MDME(206,1)=1     !W decay into e- nu_e',
            'MDME(207,1)=1     !W decay into mu nu_mu',
            'MDME(208,1)=1     !W decay into tau nu_tau',
            'MDME(209,1)=-1    !W decay into tau4 nu_tau4'),
    maxDeltaR=0.3)

akFilter3PFmatchGroomed = patJetGenJetMatch.clone(
    src=cms.InputTag("akFilter3HiGenJets"),
    matched=cms.InputTag("ak3HiCleanedGenJets"),
    resolveByMatchQuality=cms.bool(False),
    maxDeltaR=0.3)

akFilter3PFparton = patJetPartonMatch.clone(
    src=cms.InputTag("akFilter3PFJets"))

akFilter3PFcorr = patJetCorrFactors.clone(
    useNPV=cms.bool(False),
    useRho=cms.bool(False),
    #    primaryVertices = cms.InputTag("hiSelectedVertex"),
    levels=cms.vstring('L2Relative', 'L3Absolute'),
    src=cms.InputTag("akFilter3PFJets"),
    payload="AK3PF_offline")

akFilter3PFJetID = cms.EDProducer('JetIDProducer',
                                  JetIDParams,
                                  src=cms.InputTag('akFilter3CaloJets'))

#akFilter3PFclean   = heavyIonCleanedGenJets.clone(src = cms.InputTag('ak3HiCleanedGenJets'))

akFilter3PFbTagger = bTaggers("akFilter3PF", 0.3)

#create objects locally since they dont load properly otherwise
#akFilter3PFmatch = akFilter3PFbTagger.match
akFilter3PFparton = patJetPartonMatch.clone(
    src=cms.InputTag("akFilter3PFJets"),
 pythiaPylistVerbosity = cms.untracked.int32(1),
 filterEfficiency = cms.untracked.double(1.0),
 pythiaHepMCVerbosity = cms.untracked.bool(False),
 comEnergy = cms.double(13000.),
 PythiaParameters = cms.PSet(
     pythia8CommonSettingsBlock,
     pythia8CP5SettingsBlock,
     # pythia8CUEP8M1SettingsBlock,
     # pythia8aMCatNLOSettingsBlock,
     JetMatchingParameters = cms.vstring(
         'JetMatching:setMad = off',
         'JetMatching:scheme = 1',
         'JetMatching:merge = on',
         'JetMatching:jetAlgorithm = 2',
         'JetMatching:etaJetMax = 5.',
         'JetMatching:coneRadius = 1.',
         'JetMatching:slowJetPower = 1',
         'JetMatching:qCut = 25', #this is the actual merging scale
         'JetMatching:nQmatch = 4', #5 for 5-flavour scheme (matching of b-quarks)
         'JetMatching:nJetMax = 2', #number of partons in born matrix element for highest multiplicity
         'JetMatching:doShowerKt = off', #off for MLM matching, turn on for shower-kT matching
         ),
     processParameters = cms.vstring(
         'SLHA:keepSM = on',
         'SLHA:minMassSM = 10.',
         # Very important to enable override!
         'SLHA:allowUserOverride = on',
         'RHadrons:allow = on',
         'RHadrons:allowDecay = on',
         'ParticleDecays:limitTau0 = on',
         'ParticleDecays:tau0Max = 1000.1',
Exemple #57
0
    maxDeltaR=0.6)

akPuSoftDrop6PFmatchGroomed = patJetGenJetMatch.clone(
    src=cms.InputTag("akSoftDrop6HiGenJets"),
    matched=cms.InputTag("ak6HiCleanedGenJets"),
    resolveByMatchQuality=cms.bool(False),
    maxDeltaR=0.6)

akPuSoftDrop6PFparton = patJetPartonMatch.clone(
    src=cms.InputTag("akPuSoftDrop6PFJets"),
    matched=cms.InputTag("cleanedPartons"))

akPuSoftDrop6PFcorr = patJetCorrFactors.clone(
    useNPV=cms.bool(False),
    useRho=cms.bool(False),
    levels=cms.vstring('L2Relative'),
    src=cms.InputTag("akPuSoftDrop6PFJets"),
    payload="AKPu6PF_offline")

akPuSoftDrop6PFJetID = cms.EDProducer(
    'JetIDProducer', JetIDParams, src=cms.InputTag('akPuSoftDrop6CaloJets'))

# akPuSoftDrop6PFclean = heavyIonCleanedGenJets.clone(
#     src = cms.InputTag('ak6HiCleanedGenJets'))

akPuSoftDrop6PFbTagger = bTaggers("akPuSoftDrop6PF", 0.6)

# create objects locally since they dont load properly otherwise
akPuSoftDrop6PFPatJetFlavourAssociationLegacy = akPuSoftDrop6PFbTagger.PatJetFlavourAssociationLegacy
akPuSoftDrop6PFPatJetPartons = akPuSoftDrop6PFbTagger.PatJetPartons
akPuSoftDrop6PFJetTracksAssociatorAtVertex = akPuSoftDrop6PFbTagger.JetTracksAssociatorAtVertex
Exemple #58
0
import FWCore.ParameterSet.Config as cms

from GeneratorInterface.ExternalDecays.TauolaSettings_cff import *

generator = cms.EDFilter(
    "Pythia8GeneratorFilter",
    comEnergy=cms.double(13000.0),
    ExternalDecays=cms.PSet(Tauola=cms.untracked.PSet(TauolaPolar,
                                                      TauolaDefaultInputCards),
                            parameterSets=cms.vstring('Tauola')),
    crossSection=cms.untracked.double(1.0),
    filterEfficiency=cms.untracked.double(1),
    maxeventsToPrint=cms.untracked.int32(10),
    pyhiaHepMCVerbosity=cms.untracked.bool(False),
    pythiaPylistVerbosity=cms.untracked.int32(1),
    PythiaParameters=cms.PSet(processParameters=cms.vstring(
        'Tune:pp 5',
        'Tune:ee 3',
        'LeptoQuark:gg2LQLQbar = on',
        'LeptoQuark:qqbar2LQLQbar = on',
        '6:m0 = 172.5 ! top mass',
        '42:m0 = 500 ! LQ mass',
        '42:addChannel = 1 1.0 0 6 11 ! add channel LQ to e t',
        '42:0:onMode = 0 ! switch off LQ to e u',
        '42:0:bRatio = 0.0 ! switch off LQ to e u',
    ),
                              parameterSets=cms.vstring('processParameters')))
Exemple #59
0
import FWCore.ParameterSet.Config as cms

import os

process = cms.PSet()

process.fwliteInput = cms.PSet(fileNames=cms.vstring(
    '/hdfs/local/lucia/VHBBHeppyV24bis/ttHJetToNonbb_M125_13TeV_amcatnloFXFX_madspin_pythia8_mWCutfix/VHBB_HEPPY_V24bis_ttHJetToNonbb_M125_13TeV_amcatnloFXFX_madspin_Py8_mWCutfix__spr16MAv2-puspr16_HLT_80r2as_v14_ext1-v1/160911_223711/0000/tree_1.root'
),
                               maxEvents=cms.int32(-1),
                               outputEvery=cms.uint32(100000))

process.fwliteOutput = cms.PSet(
    fileName=cms.string('produceNtuple_3l_1tau.root'))

process.produceNtuple_3l_1tau = cms.PSet(
    treeName=cms.string('tree'),
    era=cms.string('2016'),
    leptonSelection=cms.string('Fakeable'),
    minNumLeptons=cms.int32(2),
    hadTauSelection=cms.string('Tight|dR03mvaMedium'),
    minNumHadTaus=cms.int32(1),
    minNumJets=cms.int32(1),
    use_HIP_mitigation_bTag=cms.bool(False),
    minNumBJets_loose=cms.int32(0),
    minNumBJets_medium=cms.int32(0),
    use_HIP_mitigation_mediumMuonId=cms.bool(False),
    isMC=cms.bool(True),
    selEventsFileName_input=cms.string(''),
    selEventsFileName_addMEM=cms.string(''),
    outputCommands=cms.vstring(
Exemple #60
0
        'file:/storage1/eliza/samples_test/MinimumBias_ZeorBias.root'
        #        'file:/data1/antoniov/MinimumBias_Commissioning10_GOODCOLL-Jun14thSkim_v1_RECO/MinimumBias_Commissioning10_GOODCOLL-Jun14thSkim_v1_RECO_EC45524A-E682-DF11-B8A7-001A92810AAA.root'
    ))

process.TFileService = cms.Service(
    "TFileService",
    fileName=cms.string('analysisHistos_pFlowNoiseThesholds.root'))

process.load('Utilities.AnalysisSequences.minimumBiasAnalysisSequences_cff')
process.load('Utilities.AnalysisSequences.outputModule_cfi')
process.output.outputCommands.append('keep *_pfCandidateNoiseThresholds_*_*')
process.output.outputCommands.append('keep *_edmNtupleEtaMax_*_*')
process.output.outputCommands.append('keep *_edmNtupleEtaMin_*_*')
process.output.outputCommands.append('keep *_edmNtupleEtaMaxNoThresholds_*_*')
process.output.outputCommands.append('keep *_edmNtupleEtaMinNoThresholds_*_*')
process.output.SelectEvents.SelectEvents = cms.vstring('selection_step')
process.output.fileName = '/data1/antoniov/Test/pFlowNoiseThesholds.root'

process.load('ForwardAnalysis.Utilities.pfCandidateNoiseThresholds_cfi')
process.load('ForwardAnalysis.Utilities.etaMaxCandViewSelector_cfi')
process.load('ForwardAnalysis.Utilities.etaMinCandViewSelector_cfi')
#process.load('ForwardAnalysis.Utilities.etaMaxCandSelector_cfi')
#process.load('ForwardAnalysis.Utilities.etaMinCandSelector_cfi')
process.etaMaxCandViewSelector.src = "pfCandidateNoiseThresholds"
process.etaMinCandViewSelector.src = "pfCandidateNoiseThresholds"
#process.etaMaxCandSelector.src = "pfCandidateNoiseThresholds"
#process.etaMinCandSelector.src = "pfCandidateNoiseThresholds"
process.etaMaxCandViewSelectorNoThresholds = process.etaMaxCandViewSelector.clone(
    src="particleFlow")
process.etaMinCandViewSelectorNoThresholds = process.etaMinCandViewSelector.clone(
    src="particleFlow")