Пример #1
0
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')
        )
def ReMatchL1(process):
    from MuonAnalysis.MuonAssociators.patMuonsWithTrigger_8E29_cff import muonMatchHLTL1
    process.muonReMatchL1DoubleMuOpen = muonMatchHLTL1.clone(
        src     = cms.InputTag("patMuons"),
        matched = cms.InputTag("patTriggerMuons"),
        filterLabels = cms.vstring('hltDoubleMuLevel1PathL1OpenFiltered'),
        maxDeltaR   = cms.double(1.2),
        maxDeltaEta = cms.double(0.2),
        fallbackToME1 = cms.bool(True),
    )
    process.patMuonsL1Rematched = cms.EDProducer( "PATTriggerMatchMuonEmbedder",
        src     = cms.InputTag(  "patMuons" ),
        matches = cms.VInputTag(cms.InputTag("muonReMatchL1DoubleMuOpen"))
    )
    process.tagMuons1MuL1Rematched = process.tagMuons1Mu.clone(src = "patMuonsL1Rematched")
    process.anyProbeMuons.src = "patMuonsL1Rematched"
    process.tpGlbAny.decay = "tagMuons1MuL1Rematched@+ anyProbeMuons@-"
    process.tnpSequenceTrigger.replace(process.anyProbeMuons, 
        process.muonReMatchL1DoubleMuOpen * 
        process.patMuonsL1Rematched *
        ( process.tagMuons1MuL1Rematched + process.anyProbeMuons )
    )
    if process.histoTrigger.isMC.value():
        process.muMcMatchL1Rematched = process.muMcMatch.clone(src = "patMuonsL1Rematched")
        process.histoTrigger.tagMatches = "muMcMatchL1Rematched"
        process.histoTrigger.probeMatches = "muMcMatchL1Rematched"
        process.tnpSequenceTrigger.replace(process.histoTrigger,
            process.muMcMatchL1Rematched *
            process.histoTrigger
        )
Пример #3
0
def customiseForUncollapsed(process):
    for producer in producers_by_type(process, "PFClusterProducer"):
        if producer.seedFinder.thresholdsByDetector[1].detector.value() == 'HCAL_ENDCAP':
            producer.pfClusterBuilder.recHitEnergyNorms                  = recHitEnergyNorms2018
            producer.seedFinder.thresholdsByDetector                     = seedFinderThresholdsByDetector2018
            producer.initialClusteringStep.thresholdsByDetector          = initialClusteringStepThresholdsByDetector2018
            producer.pfClusterBuilder.positionCalc.logWeightDenominatorByDetector         = logWeightDenominatorByDetector2018
            producer.pfClusterBuilder.allCellsPositionCalc.logWeightDenominatorByDetector = logWeightDenominatorByDetector2018

    for producer in producers_by_type(process, "PFMultiDepthClusterProducer"):
        producer.pfClusterBuilder.allCellsPositionCalc.logWeightDenominatorByDetector = logWeightDenominatorByDetector2018_HCAL
    
    for producer in producers_by_type(process, "PFRecHitProducer"):
        if producer.producers[0].name.value() == 'PFHBHERecHitCreator':
            producer.producers[0].qualityTests[0].cuts = cuts2018
    
    for producer in producers_by_type(process, "CaloTowersCreator"):
        producer.HcalPhase     = cms.int32(1)
        producer.HESThreshold1 = cms.double(0.1)
        producer.HESThreshold  = cms.double(0.2)
        producer.HEDThreshold1 = cms.double(0.1)
        producer.HEDThreshold  = cms.double(0.2)


    #remove collapser from sequence
    process.hltHbhereco = process.hltHbhePhase1Reco.clone()
    process.HLTDoLocalHcalSequence      = cms.Sequence( process.hltHcalDigis + process.hltHbhereco + process.hltHfprereco + process.hltHfreco + process.hltHoreco )
    process.HLTStoppedHSCPLocalHcalReco = cms.Sequence( process.hltHcalDigis + process.hltHbhereco )


    return process    
Пример #4
0
def makePuppiesFromMiniAOD( process ):

    process.load('CommonTools.PileupAlgos.Puppi_cff')

    process.puppi.candName = cms.InputTag('packedPFCandidates')
    process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
# kind of ugly, is there a better way to do this?

    process.pfNoLepPUPPI = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut =  cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 && abs(pdgId) != 15"))
    process.pfLeptonsPUPPET   = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) == 13 || abs(pdgId) == 11 || abs(pdgId) == 15"))

    process.puppiNoLep = process.puppi.clone()
    process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI') 

    process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))

## puppi met
    process.puppiForMET = cms.EDProducer("PuppiPhoton",
                                         candName       = cms.InputTag('packedPFCandidates'),
                                         puppiCandName  = cms.InputTag('puppi'),
                                         photonName     = cms.InputTag('slimmedPhotons'),
                                         photonId       = cms.InputTag("egmPhotonIDs:cutBasedPhotonID_PHYS14_PU20bx25_V2p1-standalone-loose"),
                                         pt             = cms.double(10),
                                         useRefs        = cms.bool(True),
                                         dRMatch        = cms.vdouble(10,10,10,10),
                                         pdgids         = cms.vint32 (22,11,211,130),
                                         weight         = cms.double(1.),
                                         useValueMap    = cms.bool(False),
                                         weightsName    = cms.InputTag('puppi'),
                                         )
    process.puppiForMET.puppiCandName    = 'puppiMerged'
Пример #5
0
def kinAxis(apt1, apt2, am1, am2) :
    return cms.PSet(
        pt1 = cms.double( apt1 ),
        pt2 = cms.double( apt2 ),
        m1 = cms.double( am1 ),
        m2 = cms.double( am2 )
        )
Пример #6
0
def MakeEventSelection( invMassMethod, _from, _to, GenMatch, _JetVeto, _VetoMoreThan2, _MET, _MT) :
    method = -1
    if invMassMethod == "Momentum" :
        method = 0
    elif invMassMethod == "GSF" :
        method = 1
    elif invMassMethod == "GSFOut" :
        method = 2
    elif invMassMethod == "SC" :
        method = 3
    elif invMassMethod == "Seed" :
        method = 4
    elif invMassMethod == "CTF" :
        method = 5

    ret = cms.PSet(
        InvMassMethod=cms.int32(method),
        InvMassMin=cms.double(_from),
        InvMassMax=cms.double(_to),
        MET=cms.double(_MET),
        MT=cms.double(_MT),
        
        ElectronsShouldMatch=cms.bool(GenMatch),
        JetVeto=cms.bool(_JetVeto),
        VetoMoreThan2Elecs=cms.bool(_VetoMoreThan2)
        )

    return ret
Пример #7
0
def customise_Reco(process):
    #lowering HO threshold with SiPM
    for prod in process.particleFlowRecHitHO.producers:
        prod.qualityTests = cms.VPSet(
            cms.PSet(
                name = cms.string("PFRecHitQTestThreshold"),
                threshold = cms.double(0.05) # new threshold for SiPM HO
            ),
            cms.PSet(
                name = cms.string("PFRecHitQTestHCALChannel"),
                maxSeverities      = cms.vint32(11),
                cleaningThresholds = cms.vdouble(0.0),
                flags              = cms.vstring('Standard')
            )
        )

    #Lower Thresholds also for Clusters!!!    

    for p in process.particleFlowClusterHO.seedFinder.thresholdsByDetector:
        p.seedingThreshold = cms.double(0.08)

    for p in process.particleFlowClusterHO.initialClusteringStep.thresholdsByDetector:
        p.gatheringThreshold = cms.double(0.05)

    for p in process.particleFlowClusterHO.pfClusterBuilder.recHitEnergyNorms:
        p.recHitEnergyNorm = cms.double(0.05)

    process.particleFlowClusterHO.pfClusterBuilder.positionCalc.logWeightDenominator = cms.double(0.05)
    process.particleFlowClusterHO.pfClusterBuilder.allCellsPositionCalc.logWeightDenominator = cms.double(0.05)

    return process
Пример #8
0
def addRhoVariables(process, seq, eleTag="gsfElectrons", muTag="muons", pfNoPUTag="pfNoPileUp"):

    process.kt6PFJets.doRhoFastjet = cms.bool(True)
    process.kt6PFJets.doAreaFastjet = cms.bool(True)
    process.kt6PFJets.Rho_EtaMax = cms.double(4.4)
    process.kt6PFJetsForIso = process.kt6PFJets.clone(Rho_EtaMax=cms.double(2.5), Ghost_EtaMax=cms.double(2.5))
    process.kt6PFJetsNoPU = process.kt6PFJets.clone(src=pfNoPUTag)
    process.kt6PFJetsForIsoNoPU = process.kt6PFJetsForIso.clone(src=pfNoPUTag)

    # Re-cluster jets w/ pfNoPileUp
    process.ak5PFJetsNoPU = process.ak5PFJets.clone(src=pfNoPUTag)

    process.load("WWAnalysis.Tools.rhoValueMapProducer_cfi")

    process.rhoMu = process.rhoValueMapProducer.clone(
        rhoTag=cms.untracked.InputTag("kt6PFJetsForIso", "rho", process.name_()), leptonTag=muTag
    )
    process.rhoEl = process.rhoMu.clone(leptonTag=eleTag)
    process.rhoMuNoPU = process.rhoValueMapProducer.clone(
        rhoTag=cms.untracked.InputTag("kt6PFJetsForIsoNoPU", "rho", process.name_()), leptonTag=muTag
    )
    process.rhoElNoPU = process.rhoMuNoPU.clone(leptonTag=eleTag)

    process.valueMaps = cms.Sequence(process.rhoMu + process.rhoEl + process.rhoMuNoPU + process.rhoElNoPU)

    seq += (
        process.ak5PFJets
        + process.kt6PFJets
        + process.kt6PFJetsForIso
        + process.pfPileUp
        * process.pfNoPileUp
        * (process.ak5PFJetsNoPU + process.kt6PFJetsNoPU + process.kt6PFJetsForIsoNoPU)
        * process.valueMaps
    )
Пример #9
0
def ageEcal(process,lumi,instLumi):
    if hasattr(process,'g4SimHits'):
        #these lines need to be further activiated by tuning on 'complete' aging for ecal 
        process.g4SimHits.ECalSD.InstLuminosity = cms.double(instLumi)
        process.g4SimHits.ECalSD.DelivLuminosity = cms.double(float(lumi))

   # available conditions
    ecal_lumis = [300,1000,3000,4500]
    ecal_conditions = [
        ['EcalIntercalibConstantsRcd','EcalIntercalibConstants_TL{:d}_upgrade_8deg_mc'],
        ['EcalIntercalibConstantsMCRcd','EcalIntercalibConstantsMC_TL{:d}_upgrade_8deg_mc'],
        ['EcalLaserAPDPNRatiosRcd','EcalLaserAPDPNRatios_TL{:d}_upgrade_8deg_mc'],
        ['EcalPedestalsRcd','EcalPedestals_TL{:d}_upgradeTIA_8deg_mc'],
        ['EcalTPGLinearizationConstRcd','EcalTPGLinearizationConst_TL{:d}_upgrade_8deg_mc'],
    ]

    # try to get conditions
    if int(lumi) in ecal_lumis:
        if not hasattr(process.GlobalTag,'toGet'):
            process.GlobalTag.toGet=cms.VPSet()
        for ecal_condition in ecal_conditions:
            process.GlobalTag.toGet.append(cms.PSet(
                record = cms.string(ecal_condition[0]),
                tag = cms.string(ecal_condition[1].format(int(lumi))),
                connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS")
                )
            )
        
    return process
Пример #10
0
def customise_TrackTrigger(process):
    process.TTStubAlgorithm_tab2013_PixelDigi_ = cms.ESProducer("TTStubAlgorithm_tab2013_PixelDigi_",
                                                                zMatchingPS = cms.bool(False),
                                                                zMatching2S = cms.bool(True),
                                                                BarrelCut = cms.vdouble( 0, 2.5, 2.5, 3, 3, 4.5, 4.5, 5.5, 5.5, 7, 7 ), #Use 0 as dummy to have direct access using DetId to the correct element
                                                                EndcapCutSet = cms.VPSet(
        cms.PSet( EndcapCut = cms.vdouble( 0 ) ), #Use 0 as dummy to have direct access using DetId to the correct element
        )
                                                                )

    process.StackedTrackerGeometryESModule = cms.ESProducer( "StackedTrackerGeometryESModule",
                                                             truncation_precision = cms.uint32(2),
                                                             z_window = cms.double(4.0),
                                                             phi_window = cms.double(0.015),
                                                             radial_window = cms.double(1.0),
                                                             make_debug_file = cms.bool(True),
                                                             
                                                             # Extras for CBC3 chip
                                                             partitionsPerRoc = cms.int32(4),
                                                             CBC3_MaxStubs = cms.uint32(3),
                                                             # Double tab2013 table as CBC3 chip uses full width -- this table for LB's (not verified numbers) design
                                                             BarrelCut = cms.vdouble( 0, 5, 5, 6, 6, 9, 9, 11, 11, 14, 14 ), #Use 0 as dummy to have direct access using DetId to the correct element
                                                             EndcapCutSet = cms.VPSet(
        cms.PSet( EndcapCut = cms.vdouble( 0 ) ), #Use 0 as dummy to have direct access using DetId to the correct element
        )
                                                             )
    
    
    return process
Пример #11
0
def defineAnalysis(process,castorDir="",reRunRho=False) :

    # our MET producer
    process.ClusteredPFMetProducer = ClusteredPFMetProducer.clone()

    #
    # configure the analyzer (cf. base values are in the StandardSelections_cfi)
    #
    process.evAnalyzer = cms.EDAnalyzer("DileptonPlusMETEventAnalyzer",
                                        dtag=cms.string('llvv'),
                                        Trigger = BaseTriggerSelection.clone(),
                                        Generator = BaseGeneratorSelection.clone(),
                                        Vertices = BaseVertexSelection.clone(),
                                        Photons = BasePhotonsSelection.clone(),
                                        LooseMuons = BaseLooseMuonsSelection.clone(),
                                        Muons = BaseMuonsSelection.clone(),
                                        LooseElectrons = BaseLooseElectronsSelection.clone(),
                                        Electrons = BaseElectronsSelection.clone(),
                                        Dileptons = BaseDileptonSelection.clone(),
                                        Jets = BaseJetSelection.clone(),
                                        AssocJets = AssocJetSelection.clone(),
                                        MET = BaseMetSelection.clone()
                                        )
    
    if(castorDir.find('12_03_13_HZZ2l2v_pat')>0):
        print ' Warning: applying PF muon patch to standard selection'
        process.evAnalyzer.Muons.source=cms.InputTag("selectedPatMuonsPFlow")
        process.evAnalyzer.Muons.sourceIsPF=cms.bool(True)
        process.evAnalyzer.LooseMuons.source=process.evAnalyzer.Muons.source
        process.evAnalyzer.LooseMuons.sourceIsPF=process.evAnalyzer.Muons.sourceIsPF

    #MVAs for IDs
    #process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi')
    #process.mvaIDs = cms.Sequence(  process.mvaTrigV0 + process.mvaNonTrigV0 )
    
    from JetMETCorrections.Configuration.JetCorrectionProducers_cff import ak5PFJetsL1L2L3
    process.ak5PFJetsL1L2L3ForMVAMET=ak5PFJetsL1L2L3.clone()
    
    #rho for muon isolation
    if(reRunRho) :
        process.pfAllNeutralHadronsAndPhotons = pfAllNeutralHadronsAndPhotons.clone( src=cms.InputTag("particleFlow") )
        process.kt6PFJetsCentralNeutral = kt4PFJets.clone(  src = cms.InputTag("pfAllNeutralHadronsAndPhotons"),
                                                            rParam = cms.double(0.6),
                                                            doAreaFastjet = cms.bool(True),
                                                            doRhoFastjet = cms.bool(True),
                                                            Ghost_EtaMax = cms.double(3.1),
                                                            Rho_EtaMax = cms.double(2.5),
                                                            inputEtMin = cms.double(0.5)
                                                            )
        process.rhoForIsolationSequence = cms.Sequence(process.pfAllNeutralHadronsAndPhotons*process.kt6PFJetsCentralNeutral)
        process.analysis = cms.Path( #process.mvaIDs +
            process.rhoForIsolationSequence +
            process.ak5PFJetsL1L2L3ForMVAMET +
            process.ClusteredPFMetProducer +
            process.evAnalyzer)
    else :
        process.analysis = cms.Path( #process.mvaIDs +
            process.ak5PFJetsL1L2L3ForMVAMET +
            process.ClusteredPFMetProducer +
            process.evAnalyzer)
Пример #12
0
def customizeHLTforMC(process):
  """adapt the HLT to run on MC, instead of data
  see Configuration/StandardSequences/Reconstruction_Data_cff.py
  which does the opposite, for RECO"""

  # PFRecHitProducerHCAL
  if 'hltParticleFlowRecHitHCAL' in process.__dict__:
    process.hltParticleFlowRecHitHCAL.ApplyPulseDPG      = cms.bool(False)
    process.hltParticleFlowRecHitHCAL.LongShortFibre_Cut = cms.double(1000000000.0)

  # customise hltHbhereco to use the Method 3 time slew parametrization and response correction for Monte Carlo (PR #11091)
  if 'hltHbhereco' in process.__dict__:
    if process.hltHbhereco._TypedParameterizable__type == 'HcalHitReconstructor':
      # 2015-2016 Run 2
      process.hltHbhereco.pedestalSubtractionType = cms.int32( 1 )
      process.hltHbhereco.pedestalUpperLimit      = cms.double( 2.7 )
      process.hltHbhereco.timeSlewParsType        = cms.int32( 3 )
      # new time slew parametrisation
      process.hltHbhereco.timeSlewPars            = cms.vdouble( 12.2999, -2.19142, 0, 12.2999, -2.19142, 0, 12.2999, -2.19142, 0 )
      # old response correction, matching the 2015D 25ns data
      process.hltHbhereco.respCorrM3              = cms.double( 1.0 )
    elif process.hltHbhereco._TypedParameterizable__type == 'HBHEPhase1Reconstructor':
      # 2017 "plan 0"
      process.hltHbhereco.algorithm.respCorrM3    = cms.double( 1.0 )

  if 'hltHbhePhase1Reco' in process.__dict__:
    if process.hltHbhePhase1Reco._TypedParameterizable__type == 'HBHEPhase1Reconstructor':
      # 2017 "plan 1"
      process.hltHbhePhase1Reco.algorithm.respCorrM3 = cms.double( 1.0 )

  return process
Пример #13
0
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
Пример #14
0
def turn_on_Pixel_aging_1000(process):
    # just incase we want aging afterall
    if hasattr(process, "mix") and hasattr(process.mix, "digitizers") and hasattr(process.mix.digitizers, "hcal"):
        process.mix.digitizers.pixel.PseudoRadDamage = cms.double(1.5)
        process.mix.digitizers.pixel.PseudoRadDamageRadius = cms.double(4.0)

    return process
Пример #15
0
def customise(process):

    if hasattr(process.VtxSmeared,"X0"):
        VertexX = process.VtxSmeared.X0
        VertexY = process.VtxSmeared.Y0
        VertexZ = process.VtxSmeared.Z0

    if hasattr(process.VtxSmeared,"MeanX"):
        VertexX = process.VtxSmeared.MeanX
        VertexY = process.VtxSmeared.MeanY
        VertexZ = process.VtxSmeared.MeanZ

    process.load("SimG4Core.Application.g4SimHits_cfi")
    process.g4SimHits.Generator.HepMCProductLabel   = 'LHCTransport'
    process.g4SimHits.Generator.MinEtaCut        = -13.0
    process.g4SimHits.Generator.MaxEtaCut        = 13.0

    process.g4SimHits.SteppingAction.MaxTrackTime = cms.double(2000.0)
    process.g4SimHits.StackingAction.MaxTrackTime = cms.double(2000.0)

    process.load('SimTransport.HectorProducer.HectorTransportCTPPS_cfi')
    process.LHCTransport.CTPPSHector.VtxMeanX  = VertexX
    process.LHCTransport.CTPPSHector.VtxMeanY  = VertexY
    process.LHCTransport.CTPPSHector.VtxMeanZ  = VertexZ

    process.transport_step = cms.Path(process.LHCTransport)
    process.psim = cms.Sequence(cms.SequencePlaceholder("randomEngineStateProducer")*process.LHCTransport*process.g4SimHits)

    return(process)
def loadElectronScaleFactor(filename):
  import json
  with open(filename) as f:
    data = json.load(f)

    etaBins = data["eta"]
    ptBins = data["pt"]

    mainSet = cms.VPSet()

    for i in range(0, len(etaBins) - 1):
      etaSet = cms.VPSet()

      for j in range(0, len(ptBins) - 1):

        pset = cms.PSet(
            pt = cms.vdouble(float(ptBins[j]), float(ptBins[j + 1])),
            value = cms.double(float(data["sf"][i][j][0])),
            error_high = cms.double(float(data["sf"][i][j][1])),
            error_low = cms.double(float(data["sf"][i][j][2])),
            )

        etaSet.append(pset)

      mainSet.append(
          cms.PSet(
            eta = cms.vdouble(float(etaBins[i]), float(etaBins[i + 1])),
            SF = etaSet
            )
          )

    return mainSet
def adjust_cone_radius(R,pfJetsJetrecoPrototype,LAJets):
    #
    rtag = "R%d" % (R*100.0)
    latag = "LA"+str(LAJets)
    #
    newPFReco = pfJetsJetrecoPrototype.clone(
        recoScaleCalcPeak = cms.PSet(
            Class = cms.string("ConstDouble"),
            value = cms.double(R)
        ),
        recoScaleCalcJet = cms.PSet(
            Class = cms.string("ConstDouble"),
            value = cms.double(R)
        )
    )
    newPFReco_module = "fftPFJetReco"+latag+rtag
    #
    newPFReco.resolution = cms.string('locallyAdaptive')
    newPFReco.nClustersRequested = cms.uint32(LAJets)
    newPFCorr = configure_fftjet_correction_producer(
    (jetCorrectionSequenceTag,), newPFReco_module)
    newPFCorr.verbose = cms.untracked.bool(False)
    newPFCorr.calculatePileup = cms.bool(False) 
    newPFCorr.subtractPileup = cms.bool(False) 
    newPFCorr_module = "fftPFJetCorrected"+latag+rtag
 
    return ((newPFReco, newPFReco_module),
            (newPFCorr, newPFCorr_module)
            )
def initJetAreaSequence(process):
  jamedian_pt_jets_value=0.
  eta_max_ghosts=6.
  from RecoJets.JetProducers.AnomalousCellParameters_cfi import AnomalousCellParameters

  from RecoJets.JetProducers.GenJetParameters_cfi import GenJetParameters
  GenJetParameters.doPUFastjet = cms.bool(False)
  GenJetParameters.doAreaFastjet = cms.bool(True)
  GenJetParameters.doRhoFastjet = cms.bool(True)
  GenJetParameters.Active_Area_Repeats = cms.int32(1)
  GenJetParameters.jetPtMin = cms.double(jamedian_pt_jets_value)
  GenJetParameters.Ghost_EtaMax= cms.double(eta_max_ghosts)


  process.kt2GenJetsWithArea = cms.EDProducer("FastjetJetProducer",
      GenJetParameters,
      AnomalousCellParameters,
      jetAlgorithm = cms.string("Kt"),
      rParam       = cms.double(0.2)
  )

  process.kt4GenJetsWithArea=process.kt2GenJetsWithArea.clone(rParam=0.4)
  process.kt8GenJetsWithArea=process.kt2GenJetsWithArea.clone(rParam=0.8)
  process.kt12GenJetsWithArea=process.kt2GenJetsWithArea.clone(rParam=1.2)

  process.GenJetsWithAreaSeq=cms.Sequence(process.kt2GenJetsWithArea+
                                process.kt4GenJetsWithArea+
                                process.kt8GenJetsWithArea+
                                process.kt12GenJetsWithArea) 
def customiseCommon(process):
    
    #####################################################################################################
    ####
    ####  Top level replaces for handling strange scenarios of early collisions
    ####

    ## TRACKING:
    ## Skip events with HV off
    process.newSeedFromTriplets.ClusterCheckPSet.MaxNumberOfPixelClusters=2000
    process.newSeedFromPairs.ClusterCheckPSet.MaxNumberOfCosmicClusters=20000
    process.secTriplets.ClusterCheckPSet.MaxNumberOfPixelClusters=2000
    process.fifthSeeds.ClusterCheckPSet.MaxNumberOfCosmicClusters = 20000
    process.fourthPLSeeds.ClusterCheckPSet.MaxNumberOfCosmicClusters=20000
    process.thTripletsA.ClusterCheckPSet.MaxNumberOfPixelClusters = 5000
    process.thTripletsB.ClusterCheckPSet.MaxNumberOfPixelClusters = 5000

    ###### FIXES TRIPLETS FOR LARGE BS DISPLACEMENT ######

    ### prevent bias in pixel vertex
    process.pixelVertices.useBeamConstraint = False
    
    ### pixelTracks
    #---- new parameters ----
    process.pixelTracks.RegionFactoryPSet.RegionPSet.nSigmaZ  = 4.06
    process.pixelTracks.RegionFactoryPSet.RegionPSet.originHalfLength = cms.double(40.6)

    ### 0th step of iterative tracking
    #---- new parameters ----
    process.newSeedFromTriplets.RegionFactoryPSet.RegionPSet.nSigmaZ   = cms.double(4.06)  
    process.newSeedFromTriplets.RegionFactoryPSet.RegionPSet.originHalfLength = 40.6

    ### 2nd step of iterative tracking
    #---- new parameters ----
    process.secTriplets.RegionFactoryPSet.RegionPSet.nSigmaZ  = cms.double(4.47)  
    process.secTriplets.RegionFactoryPSet.RegionPSet.originHalfLength = 44.7

    ## Primary Vertex
    process.offlinePrimaryVerticesWithBS.PVSelParameters.maxDistanceToBeam = 2
    process.offlinePrimaryVerticesWithBS.TkFilterParameters.maxNormalizedChi2 = 20
    process.offlinePrimaryVerticesWithBS.TkFilterParameters.maxD0Significance = 100
    process.offlinePrimaryVerticesWithBS.TkFilterParameters.minPixelLayersWithHits = 2
    process.offlinePrimaryVerticesWithBS.TkFilterParameters.minSiliconLayersWithHits = 5
    process.offlinePrimaryVerticesWithBS.TkClusParameters.TkGapClusParameters.zSeparation = 1
    process.offlinePrimaryVertices.PVSelParameters.maxDistanceToBeam = 2
    process.offlinePrimaryVertices.TkFilterParameters.maxNormalizedChi2 = 20
    process.offlinePrimaryVertices.TkFilterParameters.maxD0Significance = 100
    process.offlinePrimaryVertices.TkFilterParameters.minPixelLayersWithHits = 2
    process.offlinePrimaryVertices.TkFilterParameters.minSiliconLayersWithHits = 5
    process.offlinePrimaryVertices.TkClusParameters.TkGapClusParameters.zSeparation = 1

    ## ECAL 
    process.ecalRecHit.ChannelStatusToBeExcluded = [ 1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 14, 78, 142 ]

    ###
    ###  end of top level replacements
    ###
    ###############################################################################################

    return (process)
Пример #20
0
def makePuppies( process ):

    process.load('CommonTools.PileupAlgos.Puppi_cff')

    process.pfNoLepPUPPI = cms.EDFilter("PdgIdCandViewSelector",
                                        src = cms.InputTag("particleFlow"), 
                                        pdgId = cms.vint32( 1,2,22,111,130,310,2112,211,-211,321,-321,999211,2212,-2212 )
                                        )
    process.pfLeptonsPUPPET = cms.EDFilter("PdgIdCandViewSelector",
                                           src = cms.InputTag("particleFlow"),
                                           pdgId = cms.vint32(-11,11,-13,13),
                                           )


    process.puppiNoLep = process.puppi.clone()
    process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI') 

    process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))

## puppi met
    process.puppiForMET = cms.EDProducer("PuppiPhoton",
                                         candName       = cms.InputTag('packedPFCandidates'),
                                         puppiCandName  = cms.InputTag('puppi'),
                                         photonName     = cms.InputTag('slimmedPhotons'),
                                         photonId       = cms.InputTag("egmPhotonIDs:cutBasedPhotonID_PHYS14_PU20bx25_V2p1-standalone-loose"),
                                         pt             = cms.double(10),
                                         useRefs        = cms.bool(True),
                                         dRMatch        = cms.vdouble(10,10,10,10),
                                         pdgids         = cms.vint32 (22,11,211,130),
                                         weight         = cms.double(1.),
                                         useValueMap    = cms.bool(False),
                                         weightsName    = cms.InputTag('puppi'),
                                         )
    process.puppiForMET.puppiCandName    = 'puppiMerged'
Пример #21
0
def configureFakeRateProductionPAT(process, recoTauProducerName = 'hpsPFTauProducer', recoTauPreselFlag = 'ewkTauId',
                                   patTauProducerName = 'patTaus', frSet = 'ewkTauIdHPSloose', method = None,
                                   prePatProdSequenceName = "producePrePat"):

    # check validity of method parameter
    if method is None:
        raise ValueError("Undefined method Parameter !!")
    else:
        if method != "simple" and method != "CDF":
            raise ValueError("Invalid method Parameter !!")

    prePatProdSequence = getattr(process, prePatProdSequenceName)

    # produce fake-rates
    frProdConfigRECO = configureFakeRateProductionRECO(process, recoTauProducerName, frSet)
    prePatProdSequence += frProdConfigRECO['sequence']

    # compute fake-rate weights
    #
    # NOTE: jet weights are computed for all (shrinking signal cone) reco::PFTaus,
    #       but only those tau-jet candidates passing preselection on PAT level
    #       must enter event weight computation on analysis level !!
    #
    process.load("TauAnalysis.BgEstimationTools.fakeRateJetWeightProducer_cfi")
    process.bgEstFakeRateJetWeights.frTypes = cms.PSet()
    for frType, patLUT in frProdConfigRECO['frConfig'].items():
        pset = cms.PSet(
            tauJetDiscriminators = cms.VPSet(cms.PSet(
                tauJetIdEffSource = cms.InputTag(frProdConfigRECO['frConfig']['ZTTsim']),
            qcdJetFakeRateSource = cms.InputTag(patLUT),
                tauJetDiscrSource = cms.InputTag(recoTauPreselFlag)
            ))
        )
        setattr(process.bgEstFakeRateJetWeights.frTypes, frType, pset)
    process.bgEstFakeRateJetWeights.allTauJetSource = cms.InputTag(recoTauProducerName)    
    process.bgEstFakeRateJetWeights.preselTauJetSource = cms.InputTag(recoTauProducerName)
    process.bgEstFakeRateJetWeights.method = method
    # EK: put a minPt cut on the taus so we don't get a ton of errors.
    process.bgEstFakeRateJetWeights.minJetPt = 17.0
    prePatProdSequence += process.bgEstFakeRateJetWeights

    # add jet weights computed for tau id. efficiency shifted up/down by one sigma
    if method == "CDF":
        process.bgEstFakeRateJetWeightsSysTauIdEffUp = copy.deepcopy(process.bgEstFakeRateJetWeights)
        process.bgEstFakeRateJetWeightsSysTauIdEffUp.shiftTauIdEff = cms.double(+0.23)
        prePatProdSequence += process.bgEstFakeRateJetWeightsSysTauIdEffUp

        process.bgEstFakeRateJetWeightsSysTauIdEffDown = copy.deepcopy(process.bgEstFakeRateJetWeights)
        process.bgEstFakeRateJetWeightsSysTauIdEffDown.shiftTauIdEff = cms.double(-0.23)
        prePatProdSequence += process.bgEstFakeRateJetWeightsSysTauIdEffDown

    # add fake-rates to pat::Tau
    frConfigParameters = getFakeRateConfigParameters(process)
    patTauProducer = getattr(process, patTauProducerName)
    for frType, frConfig in frConfigParameters.items():
        setattr(patTauProducer.efficiencies, frConfig['patLabel'], frConfig['srcJetWeight'])
    patTauProducer.addEfficiencies = cms.bool(True)

    return frProdConfigRECO
def customise(process):

    process.g4SimHits.StackingAction.RusRoEcalNeutron = cms.double(0.3)
    process.g4SimHits.StackingAction.RusRoEcalNeutronLimit = cms.double(10.0)
    process.g4SimHits.StackingAction.RusRoHcalNeutron = cms.double(0.3)
    process.g4SimHits.StackingAction.RusRoHcalNeutronLimit = cms.double(10.0)

    return process
def customise(process):

    # extended geometric acceptance (full CASTOR acceptance)

    process.g4SimHits.Generator.MinEtaCut = cms.double(-7.7)
    process.g4SimHits.CastorSD.nonCompensationFactor = cms.double(0.77)

    return(process)
Пример #24
0
def customiseRR(process):

    # Russian roulette disabled - by default it is enabled
  if hasattr(process,'g4SimHits'):
    process.g4SimHits.StackingAction.RusRoGammaEnergyLimit = cms.double(0.0)
    process.g4SimHits.StackingAction.RusRoNeutronEnergyLimit = cms.double(0.0)

    return(process)
Пример #25
0
def addFatJet(process):
    from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets
    process.ca8PFJetsCHS = ak5PFJets.clone(
        src = 'pfNoPileUp',
        jetPtMin = cms.double(10.0),
        doAreaFastjet = cms.bool(True),
        rParam = cms.double(0.8),
        jetAlgorithm = cms.string("CambridgeAachen"),
    )

    jetSource = 'ca8PFJetsCHS'

    # corrections 
    from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import patJetCorrFactors
    process.patJetCorrFactorsCA8CHS = patJetCorrFactors.clone()
    process.patJetCorrFactorsCA8CHS.src = jetSource
    # will need to add L2L3 corrections in the cfg
    process.patJetCorrFactorsCA8CHS.levels = ['L1FastJet', 'L2Relative', 'L3Absolute']
    process.patJetCorrFactorsCA8CHS.payload = 'AK7PFchs'
    process.patJetCorrFactorsCA8CHS.useRho = True

    # pat jet
    from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import patJets
    process.patJetsCA8CHS = patJets.clone()
    process.patJetsCA8CHS.jetSource = jetSource
    process.patJetsCA8CHS.addJetCharge = False
    process.patJetsCA8CHS.embedCaloTowers = False
    process.patJetsCA8CHS.embedPFCandidates = False
    process.patJetsCA8CHS.addAssociatedTracks = False
    process.patJetsCA8CHS.addBTagInfo = False
    process.patJetsCA8CHS.addDiscriminators = False
    process.patJetsCA8CHS.getJetMCFlavour = False
    process.patJetsCA8CHS.jetCorrFactorsSource = cms.VInputTag(cms.InputTag('patJetCorrFactorsCA8CHS'))
    process.patJetsCA8CHS.genPartonMatch = cms.InputTag('patJetPartonMatchCA8CHS')
    process.patJetsCA8CHS.genJetMatch = cms.InputTag('patJetGenJetMatchCA8CHS')

    from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets
    process.selectedPatJetsCA8CHS = selectedPatJets.clone()
    process.selectedPatJetsCA8CHS.src = 'patJetsCA8CHS'
    process.selectedPatJetsCA8CHS.cut = 'pt()>20'


#process.jetMCSequenceCA8CHS = cms.Sequence(
    #process.patJetPartonMatchCA8CHS +
    #process.genParticlesForJetsNoNu +
    #process.ca8GenJetsNoNu +
    #process.patJetGenJetMatchCA8CHS
    #)

    process.PATJetSequenceCA8CHS = cms.Sequence(
        process.ca8PFJetsCHS +
        #process.jetMCSequenceCA8CHS +
        process.patJetCorrFactorsCA8CHS
        #process.patJetsCA8CHS +
        #process.selectedPatJetsCA8CHS
        )

    process.PATJetPathCA8CHS = cms.Path ( process.PATJetSequenceCA8CHS )
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
Пример #27
0
def psetNormalizedGsfChi2Cut(wpEB, wpEE):
    return cms.PSet( 
        cutName = cms.string('GsfEleNormalizedGsfChi2Cut'),
        normalizedGsfChi2CutValueEB = cms.double( wpEB.normalizedGsfChi2Cut ),
        normalizedGsfChi2CutValueEE = cms.double( wpEE.normalizedGsfChi2Cut ),
        barrelCutOff = cms.double(ebCutOff),
        needsAdditionalProducts = cms.bool(False),
        isIgnored = cms.bool(False)
        )
Пример #28
0
def psetEInerseMinusPInverseCut(wpEB, wpEE):
    return cms.PSet( 
        cutName = cms.string('GsfEleEInverseMinusPInverseCut'),
        eInverseMinusPInverseCutValueEB = cms.double( wpEB.absEInverseMinusPInverseCut ),
        eInverseMinusPInverseCutValueEE = cms.double( wpEE.absEInverseMinusPInverseCut ),
        barrelCutOff = cms.double(ebCutOff),
        needsAdditionalProducts = cms.bool(False),
        isIgnored = cms.bool(False)
        )
Пример #29
0
def psetDPhiInCut(wpEB, wpEE):
    return cms.PSet( 
        cutName = cms.string('GsfEleDPhiInCut'),
        dPhiInCutValueEB = cms.double( wpEB.dPhiInCut ),
        dPhiInCutValueEE = cms.double( wpEE.dPhiInCut ),
        barrelCutOff = cms.double(ebCutOff),
        needsAdditionalProducts = cms.bool(False),
        isIgnored = cms.bool(False)
        )
Пример #30
0
def psetHadronicOverEMCut(wpEB, wpEE):
    return cms.PSet( 
        cutName = cms.string('GsfEleHadronicOverEMCut'),
        hadronicOverEMCutValueEB = cms.double( wpEB.hOverECut ),
        hadronicOverEMCutValueEE = cms.double( wpEE.hOverECut ),
        barrelCutOff = cms.double(ebCutOff),
        needsAdditionalProducts = cms.bool(False),
        isIgnored = cms.bool(False)
        )
Пример #31
0
    'L1TriggerConfig.L1GtConfigProducers.L1GtTriggerMaskTechTrigConfig_cff')
process.load('HLTrigger/HLTfilters/hltLevel1GTSeed_cfi')

####################################################################################
##################################good collisions############################################

#### 44x
#process.primaryVertexFilter = cms.EDFilter("GoodVertexFilter",
#                                                      vertexCollection = cms.InputTag('offlinePrimaryVertices'),
#                                                      minimumNDOF = cms.uint32(4) ,
#                                                      maxAbsZ = cms.double(24),
#                                                      maxd0 = cms.double(2)
#                                           )

## 53x
pvSelection = cms.PSet(minNdof=cms.double(4.),
                       maxZ=cms.double(24.),
                       maxRho=cms.double(2.))

process.goodOfflinePrimaryVertices = cms.EDFilter(
    "PrimaryVertexObjectFilter",  # checks for fake PVs automatically
    filterParams=pvSelection,
    filter=cms.bool(False),  # use only as producer
    src=cms.InputTag('offlinePrimaryVertices'))

process.primaryVertexFilter = process.goodOfflinePrimaryVertices.clone(
    filter=True)

process.noscraping = cms.EDFilter(
    "FilterOutScraping",
    applyfilter=cms.untracked.bool(True),
Пример #32
0
import FWCore.ParameterSet.Config as cms

#from Configuration.Generator.PythiaUEZ2Settings_cfi import *
from Configuration.Generator.PythiaUEZ2starSettings_cfi import *
generator = cms.EDFilter(
    "Pythia6HadronizerFilter",
    pythiaHepMCVerbosity=cms.untracked.bool(False),
    maxEventsToPrint=cms.untracked.int32(0),
    pythiaPylistVerbosity=cms.untracked.int32(0),
    comEnergy=cms.double(8000.0),
    PythiaParameters=cms.PSet(
        pythiaUESettingsBlock,
        processParameters=cms.vstring(
            '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) = 1500.0D0  ! bprime quarks mass',
            'PMAS(7,2) = 15.0D0',
            'PMAS(7,3) = 150.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',
Пример #33
0
import FWCore.ParameterSet.Config as cms

#
# This is the include file with the parameters
# for the DTCombinatorialPatternReco algorithm,
# which is the concrete algo for the DTRecSegment2D production.
# The linear Drift algos is used.
#
# The reconstruction algo and its parameter set
from RecoLocalMuon.DTRecHit.DTLinearDriftAlgo_cfi import *
DTCombinatorialPatternReco2DAlgo_LinearDrift = cms.PSet(
    Reco2DAlgoConfig=cms.PSet(
        # Parameters for the updator
        # this is the RecHit1D algo!!
        DTLinearDriftAlgo,
        segmCleanerMode=cms.int32(2),
        AlphaMaxPhi=cms.double(1.0),
        MaxAllowedHits=cms.uint32(50),
        # Parameters for the cleaner
        nSharedHitsMax=cms.int32(2),
        AlphaMaxTheta=cms.double(0.9),
        debug=cms.untracked.bool(False),
        nUnSharedHitsMin=cms.int32(2),
        # Parameters for  T0 fit segment in the Updator and
        hit_afterT0_resolution=cms.double(0.03),
        performT0_vdriftSegCorrection=cms.bool(False),
        performT0SegCorrection=cms.bool(False)),
    Reco2DAlgoName=cms.string('DTCombinatorialPatternReco'))
Пример #34
0
def getZeroBias_SinglePixelTrackVPSet():
    ret = cms.VPSet()
    partialPathName = "HLT_ZeroBias_SinglePixelTrack_v"
    hltPixelTracksZB = cms.PSet(
        triggerSelection=cms.string(partialPathName + "*"),
        handlerType=cms.string("FromHLT"),
        partialPathName=cms.string(partialPathName),
        partialFilterName=cms.string("hltMinBiasPixelFilt"),
        dqmhistolabel=cms.string("hltPixelTracks"),
        mainDQMDirname=cms.untracked.string(fsqdirname),
        singleObjectsPreselection=cms.string("1==1"),
        singleObjectDrawables=cms.VPSet(
            cms.PSet(name=cms.string("pt"),
                     expression=cms.string("pt"),
                     bins=cms.int32(50),
                     min=cms.double(0.4),
                     max=cms.double(10)),
            cms.PSet(name=cms.string("eta"),
                     expression=cms.string("eta"),
                     bins=cms.int32(100),
                     min=cms.double(-2.5),
                     max=cms.double(2.5)),
            cms.PSet(name=cms.string("phi"),
                     expression=cms.string("phi"),
                     bins=cms.int32(100),
                     min=cms.double(-3.15),
                     max=cms.double(3.15))),
        combinedObjectSelection=cms.string("1==1"),
        combinedObjectSortCriteria=cms.string("at(0).pt"),
        combinedObjectDimension=cms.int32(1),
        combinedObjectDrawables=cms.VPSet())
    ret.append(hltPixelTracksZB)

    # note: for global efficiency (ie not efficiency as a funtion of something)
    # calculation we use RecoTrack handler in a bit twisted way.
    #     RecoTrack handler assumes, that the efficiency calculation is done
    #   only for events with at least one offline track (from generalTracks collection)
    #   passing the selection criteria from singleObjectsPreselection variable
    #     Such events are used to fill 1-bin-large-histogram with a range -0.5...0.5
    #     Note, that the histogram is always filled with the 0 value ("0*" part in
    #   expression string). The "at(0).pt()" part is needed to make expression parses
    #   happy.
    tracksCountZB = cms.PSet(
        triggerSelection=cms.string(partialPathName + "*"),
        handlerType=cms.string("RecoTrack"),
        inputCol=cms.InputTag("generalTracks"),
        # l parameters
        partialPathName=cms.string(partialPathName),
        partialFilterName=cms.string("hltL1sETT"),
        dqmhistolabel=cms.string("zb"),
        mainDQMDirname=cms.untracked.string(fsqdirname),
        singleObjectsPreselection=cms.string("pt > 0.4 && abs(eta) < 2.4"),
        singleObjectDrawables=cms.VPSet(),
        combinedObjectSelection=cms.string("1==1"),
        combinedObjectSortCriteria=cms.string('at(0).pt()'),  # doesnt matter
        combinedObjectDimension=cms.int32(1),
        combinedObjectDrawables=cms.VPSet(
            cms.PSet(name=cms.string("Eff_nominator"),
                     expression=cms.string('0*at(0).pt()'),
                     bins=cms.int32(1),
                     min=cms.double(-0.5),
                     max=cms.double(0.5))))
    ret.append(tracksCountZB)
    tracksCountDenomZB = tracksCountZB.clone(
        triggerSelection="HLT_ZeroBias_v*")
    tracksCountDenomZB.combinedObjectDrawables = cms.VPSet(
        cms.PSet(name=cms.string("Eff_denominator"),
                 expression=cms.string("0*at(0).pt()"),
                 bins=cms.int32(1),
                 min=cms.double(-0.5),
                 max=cms.double(0.5)))
    ret.append(tracksCountDenomZB)

    return ret
Пример #35
0
def getDoublePFJet(thresholds, flavour=None, etaMin=-1, srcType="genJets"):
    if srcType == "genJets":
        inputCol = cms.InputTag("ak4GenJets")
        handlerType = "FromRecoCandidate"
        label = srcType
    elif srcType == "ak4PFJetsCHS":
        inputCol = cms.InputTag("ak4PFJetsCHS")
        handlerType = "RecoPFJetWithJEC"
        label = srcType
    elif srcType == "hlt":
        inputCol = cms.InputTag("S")
        handlerType = "FromHLT"
        label = srcType
    else:
        raise Exception("Whooops!")

    combinedObjectSortCriteria = "at(0).pt + at(1).pt"
    combinedObjectSelection = "1 == 1"
    if flavour != None and "FB" in flavour:
        combinedObjectSortCriteria = "(" + combinedObjectSortCriteria + ")*(  ? at(0).eta*at(1).eta < 0 ? 1 : 0 )"
        combinedObjectSelection = "at(0).eta*at(1).eta < 0"

    if etaMin == None:
        etaMin = -1

    ret = cms.VPSet()
    for t in thresholds:
        partialPathName = "HLT_DiPFJet" + str(t) + "_"
        if flavour != None:
            partialPathName += flavour + "_"
        partialPathName += "v"

        marginLow = max(t - t // 2, 15)
        ptBinLow = max(t - marginLow, 0)
        marginHigh = min(max(t // 3, 15), 50)
        ptBinHigh = t + marginHigh
        ptBins = min(100, ptBinHigh - ptBinLow)
        fromJets = cms.PSet(
            triggerSelection=cms.string(partialPathName + "*"),
            handlerType=cms.string(handlerType),
            PFJetCorLabel=cms.InputTag("ak4PFL1FastL2L3Corrector"),
            inputCol=inputCol,
            partialPathName=cms.string(partialPathName),
            partialFilterName=cms.string("hltDoublePFJet"),
            dqmhistolabel=cms.string(label),
            mainDQMDirname=cms.untracked.string(fsqdirname),
            singleObjectsPreselection=cms.string(
                "abs(eta) < 5.5 && abs(eta) > " + str(etaMin)),
            #singleObjectsPreselection = cms.string("pt > 15 && abs(eta) < 5.5 && abs(eta) > " + str(etaMin) ),
            singleObjectDrawables=cms.VPSet(),
            combinedObjectSelection=cms.string(combinedObjectSelection),
            combinedObjectSortCriteria=cms.string(combinedObjectSortCriteria),
            combinedObjectDimension=cms.int32(2),
            combinedObjectDrawables=cms.VPSet(
                #cms.PSet (name = cms.string("ptLead"), expression = cms.string("max(at(0).pt, at(1).pt())"),
                #          bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)),
                #cms.PSet (name = cms.string("ptSublead"), expression = cms.string("min(at(0).pt, at(1).pt())"),
                #          bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)),
                cms.PSet(name=cms.string("ptMostFwd"),
                         expression=cms.string(
                             "? at(0).eta > at(1).eta ? at(0).pt : at(1).pt"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)),
                cms.PSet(name=cms.string("ptMostBkw"),
                         expression=cms.string(
                             "? at(0).eta > at(1).eta ? at(1).pt : at(0).pt"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)),
                cms.PSet(
                    name=cms.string("etaMostFwd"),
                    expression=cms.string(
                        "? at(0).eta > at(1).eta ? at(0).eta : at(1).eta"),
                    bins=cms.int32(52),
                    min=cms.double(-5.2),
                    max=cms.double(5.2)),
                cms.PSet(
                    name=cms.string("etaMostBkw"),
                    expression=cms.string(
                        "? at(0).eta > at(1).eta ? at(1).eta : at(0).eta"),
                    bins=cms.int32(52),
                    min=cms.double(-5.2),
                    max=cms.double(5.2)),
                #cms.PSet (name = cms.string("pt_nominator"), expression = cms.string("min(at(0).pt, at(1).pt)"),
                #         bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)  )
            ))
        #fromJets.triggerSelection = cms.string("HLT_ZeroBias_v*")
        ret.append(fromJets)
        if srcType != "hlt":
            fromJets.combinedObjectDrawables.append(
                cms.PSet(name=cms.string("ptm_nominator"),
                         expression=cms.string("min(at(0).pt, at(1).pt)"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)))

            fromJetsDenom = fromJets.clone(triggerSelection="HLT_ZeroBias_v*")
            fromJetsDenom.singleObjectDrawables = cms.VPSet()
            fromJetsDenom.combinedObjectDrawables = cms.VPSet(
                cms.PSet(name=cms.string("ptm_denominator"),
                         expression=cms.string("min(at(0).pt, at(1).pt)"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)))
            ret.append(fromJetsDenom)

    return ret
import FWCore.ParameterSet.Config as cms

# reference: https://github.com/cms-sw/genproductions/blob/master/python/EightTeV/SingleMuMinusFlatPt0p2To100_cff.py
generator = cms.EDProducer("FlatRandomOneOverPtGunProducer",
    PGunParameters = cms.PSet(
        MaxOneOverPt = cms.double(0.5),
        MinOneOverPt = cms.double(0.0005),
        PartID = cms.vint32(13),
        MaxEta = cms.double(2.5),
        MaxPhi = cms.double(3.14159265359),
        MinEta = cms.double(-2.5),
        MinPhi = cms.double(-3.14159265359),
        #XFlatSpread = cms.double(1.5),  ## in mm
        #YFlatSpread = cms.double(1.5),  ## in mm
        #ZFlatSpread = cms.double(150.), ## in mm
        RandomCharge = cms.bool(True),
        ReallyFlat = cms.bool(True),
    ),
    Verbosity = cms.untracked.int32(0),
    psethack = cms.string('single muon+/- 1/pt 0.0005 to 0.5'),
    AddAntiParticle = cms.bool(False),
    firstRun = cms.untracked.uint32(1)
)
Пример #37
0
# Setting input particle/jet collections to be used by the tools
genParticleCollection = ''
genJetCollection = 'ak4GenJetsCustom'

if options.runOnAOD:
    genParticleCollection = 'genParticles'
    ## producing a subset of genParticles to be used for jet reclustering
    from RecoJets.Configuration.GenJetParticles_cff import genParticlesForJetsNoNu
    process.genParticlesForJetsCustom = genParticlesForJetsNoNu.clone(
        src=genParticleCollection)
    patAlgosToolsTask.add(process.genParticlesForJetsCustom)
    # Producing own jets for testing purposes
    from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
    process.ak4GenJetsCustom = ak4GenJets.clone(
        src='genParticlesForJetsCustom',
        rParam=cms.double(0.4),
        jetAlgorithm=cms.string("AntiKt"))
    patAlgosToolsTask.add(process.ak4GenJetsCustom)
else:
    genParticleCollection = 'prunedGenParticles'
    genJetCollection = 'slimmedGenJets'

# Supplies PDG ID to real name resolution of MC particles
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi")

# Ghost particle collection used for Hadron-Jet association
# MUST use proper input particle collection
from PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi import selectedHadronsAndPartons
process.selectedHadronsAndPartons = selectedHadronsAndPartons.clone(
    particles=genParticleCollection)
patAlgosToolsTask.add(process.selectedHadronsAndPartons)
Пример #38
0
initialStepTrajectoryFilterBase = TrackingTools.TrajectoryFiltering.TrajectoryFilter_cff.CkfBaseTrajectoryFilter_block.clone(
    minimumNumberOfHits=3, minPt=0.2)
import RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeTrajectoryFilter_cfi
initialStepTrajectoryFilterShape = RecoPixelVertexing.PixelLowPtUtilities.StripSubClusterShapeTrajectoryFilter_cfi.StripSubClusterShapeTrajectoryFilterTIX12.clone(
)
initialStepTrajectoryFilter = cms.PSet(
    ComponentType=cms.string('CompositeTrajectoryFilter'),
    filters=cms.VPSet(
        cms.PSet(refToPSet_=cms.string('initialStepTrajectoryFilterBase')),
        cms.PSet(refToPSet_=cms.string('initialStepTrajectoryFilterShape'))),
)

import RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimatorESProducer_cfi
initialStepChi2Est = RecoTracker.MeasurementDet.Chi2ChargeMeasurementEstimatorESProducer_cfi.Chi2ChargeMeasurementEstimator.clone(
    ComponentName=cms.string('initialStepChi2Est'),
    nSigma=cms.double(3.0),
    MaxChi2=cms.double(30.0),
    clusterChargeCut=cms.PSet(
        refToPSet_=cms.string('SiStripClusterChargeCutLoose')),
    pTChargeCutThreshold=cms.double(15.))

import RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi
initialStepTrajectoryBuilder = RecoTracker.CkfPattern.GroupedCkfTrajectoryBuilder_cfi.GroupedCkfTrajectoryBuilder.clone(
    trajectoryFilter=cms.PSet(
        refToPSet_=cms.string('initialStepTrajectoryFilter')),
    alwaysUseInvalidHits=True,
    maxCand=3,
    estimator=cms.string('initialStepChi2Est'),
    maxDPhiForLooperReconstruction=cms.double(2.0),
    maxPtForLooperReconstruction=cms.double(0.7))
import FWCore.ParameterSet.Config as cms

from PhysicsTools.SelectorUtils.centralIDRegistry import central_id_registry

ebMax = 1.4442
eeMin = 1.566
ebCutOff = 1.479
heepElectronID_HEEPV50_CSA14_startup = cms.PSet(
    idName=cms.string("heepElectronID-HEEPV50-CSA14-startup"),
    cutFlow=cms.VPSet(
        cms.PSet(cutName=cms.string("MinPtCut"),
                 minPt=cms.double(35.0),
                 needsAdditionalProducts=cms.bool(False),
                 isIgnored=cms.bool(False)),
        cms.PSet(cutName=cms.string("GsfEleSCEtaMultiRangeCut"),
                 useAbsEta=cms.bool(True),
                 allowedEtaRanges=cms.VPSet(
                     cms.PSet(minEta=cms.double(0.0),
                              maxEta=cms.double(ebMax)),
                     cms.PSet(minEta=cms.double(eeMin),
                              maxEta=cms.double(2.5))),
                 needsAdditionalProducts=cms.bool(False),
                 isIgnored=cms.bool(False)),
        cms.PSet(cutName=cms.string('GsfEleDEtaInLinearCut'),
                 constTermEB=cms.double(0.016),
                 constTermEE=cms.double(0),
                 slopeTermEB=cms.double(-1E-4),
                 slopeTermEE=cms.double(0),
                 minValueEB=cms.double(0.004),
                 minValueEE=cms.double(0.02),
                 needsAdditionalProducts=cms.bool(False),
Пример #40
0
from DQMOffline.RecoB.bTagTrackBProbabilityAnalysis_cff import *
from DQMOffline.RecoB.bTagGenericAnalysis_cff import *
from DQMOffline.RecoB.bTagSimpleSVAnalysis_cff import *
from DQMOffline.RecoB.bTagSoftLeptonAnalysis_cff import *
from DQMOffline.RecoB.bTagSoftLeptonByPtAnalysis_cff import *
from DQMOffline.RecoB.bTagSoftLeptonByIPAnalysis_cff import *
from DQMOffline.RecoB.bTagCommon_cff import *
bTagValidation = cms.EDAnalyzer("BTagPerformanceAnalyzerMC",
    bTagCommonBlock,
    finalizeOnly = cms.bool(False),
    applyPtHatWeight = cms.bool(False),
    jetCorrection = cms.string(''),
    recJetMatching = cms.PSet(
        refJetCorrection = cms.string(''),
        recJetCorrection = cms.string(''),
        maxChi2 = cms.double(50),
        # Corrected calo jets
        sigmaDeltaR = cms.double(0.1),
        sigmaDeltaE = cms.double(0.15)
    ),
    finalizePlots = cms.bool(True),
    tagConfig = cms.VPSet(
        cms.PSet(
            bTagTrackIPAnalysisBlock,
            type = cms.string('TrackIP'),
            label = cms.InputTag("impactParameterTagInfos"),
            folder = cms.string("IPTag")
        ), 
        cms.PSet(
            bTagCombinedSVAnalysisBlock,
            ipTagInfos = cms.InputTag("impactParameterTagInfos"),
        addDiscriminators = True,
        addAssociatedTracks = True,
        addJetCharge = False,
        addJetID = False,
        getJetMCFlavour = True,
        addGenPartonMatch = True,
        addGenJetMatch = True,
        embedGenJetMatch = True,
        embedGenPartonMatch = True,
        # embedCaloTowers = False,
        # embedPFCandidates = True
        )

akFilter5PFNjettiness = Njettiness.clone(
		    src = cms.InputTag("akFilter5PFJets"),
           	    R0  = cms.double( 0.5)
)
akFilter5PFpatJetsWithBtagging.userData.userFloats.src += ['akFilter5PFNjettiness:tau1','akFilter5PFNjettiness:tau2','akFilter5PFNjettiness:tau3']

akFilter5PFJetAnalyzer = inclusiveJetAnalyzer.clone(jetTag = cms.InputTag("akFilter5PFpatJetsWithBtagging"),
                                                             genjetTag = 'ak5HiGenJets',
                                                             rParam = 0.5,
                                                             matchJets = cms.untracked.bool(False),
                                                             matchTag = 'patJetsWithBtagging',
                                                             pfCandidateLabel = cms.untracked.InputTag('particleFlowTmp'),
                                                             trackTag = cms.InputTag("hiGeneralTracks"),
                                                             fillGenJets = True,
                                                             isMC = True,
							     doSubEvent = True,
                                                             useHepMC = cms.untracked.bool(False),
							     genParticles = cms.untracked.InputTag("genParticles"),
    TPGWriteSli = cms.uint32(1),
    TPGWriteWei = cms.uint32(1),
    TPGWriteLut = cms.uint32(1),
    TPGWriteFgr = cms.uint32(1),
    TPGWriteBxt = cms.uint32(0),
    TPGWriteBtt = cms.uint32(0), #do not change

    writeToFiles = cms.bool(True),
    outFile = cms.string('TPG_beamv4_128_mc_ideal.txt'), #modif
   #### TPG config tag and version (if not given it will be automatically given ) ####
    TPGtag = cms.string('BEAMV4128MCIDEAL'),
    TPGversion = cms.uint32(1),
                                        
   #### TPG calculation parameters ####
    useTransverseEnergy = cms.bool(True),    ## true when TPG computes transverse energy, false for energy
    Et_sat_EB = cms.double(128.0),            ## Saturation value (in GeV) of the TPG before the compressed-LUT (rem: with 35.84 the TPG_LSB = crystal_LSB)
    Et_sat_EE = cms.double(128.0),            ## Saturation value (in GeV) of the TPG before the compressed-LUT (rem: with 35.84 the TPG_LSB = crystal_LSB)

    sliding = cms.uint32(0),                 ## Parameter used for the FE data format, should'nt be changed

    weight_timeShift = cms.double(0.),       ## weights are computed shifting the timing of the shape by this amount in ns: val>0 => shape shifted to the right
    weight_sampleMax = cms.uint32(3),        ## position of the maximum among the 5 samples used by the TPG amplitude filter
    weight_unbias_recovery = cms.bool(True), ## true if weights after int conversion are forced to have sum=0. Pb, in that case it can't have sum f*w = 1

    forcedPedestalValue = cms.int32(-3),     ## use this value instead of getting it from DB or MC
                                             ## -1: means use value from DB or MC.
                                             ## -2: ped12 = 0 used to cope with FENIX bug
                                             ## -3: used with sFGVB: baseline subtracted is pedestal-offset*sin(theta)/G with G=mult*2^-(shift+2) 
    pedestal_offset =  cms.uint32(150),      ## pedestal offset used with option forcedPedestalValue = -3 NOTE: depends on saturation scale (300 for 64 GeV)

    useInterCalibration = cms.bool(True),    ## use or not values from DB. If not, 1 is assumed
Пример #43
0
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:mc', '')

process.generator = cms.EDFilter(
    "Pythia6GeneratorFilter",
    ExternalDecays=cms.PSet(Tauola=cms.untracked.PSet(
        UseTauolaPolarization=cms.bool(True),
        InputCards=cms.PSet(mdtau=cms.int32(0),
                            pjak2=cms.int32(0),
                            pjak1=cms.int32(0))),
                            parameterSets=cms.vstring('Tauola')),
    maxEventsToPrint=cms.untracked.int32(5),
    pythiaPylistVerbosity=cms.untracked.int32(0),
    filterEfficiency=cms.untracked.double(1.0),
    pythiaHepMCVerbosity=cms.untracked.bool(False),
    comEnergy=cms.double(8000.0),
    crossSection=cms.untracked.double(1.0),
    UseExternalGenerators=cms.untracked.bool(True),
    PythiaParameters=cms.PSet(
        pythiaUESettings=cms.vstring(
            'MSTU(21)=1     ! Check on possible errors during program execution',
            'MSTJ(22)=2     ! Decay those unstable particles',
            'PARJ(71)=10 .  ! for which ctau  10 mm',
            'MSTP(33)=0     ! no K factors in hard cross sections',
            'MSTP(2)=1      ! which order running alphaS',
            'MSTP(51)=10042 ! structure function chosen (external PDF CTEQ6L1)',
            'MSTP(52)=2     ! work with LHAPDF',
            'PARP(82)=1.921 ! pt cutoff for multiparton interactions',
            'PARP(89)=1800. ! sqrts for which PARP82 is set',
            'PARP(90)=0.227 ! Multiple interactions: rescaling power',
            'MSTP(95)=6     ! CR (color reconnection parameters)',
Пример #44
0
process.load('IOMC.RandomEngine.IOMC_cff')

if hasattr(process, 'MessageLogger'):
    process.MessageLogger.categories.append('HCalGeom')
    process.MessageLogger.categories.append('HcalSim')

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

process.load("IOMC.RandomEngine.IOMC_cff")
process.RandomNumberGeneratorService.generator.initialSeed = 456789
process.RandomNumberGeneratorService.g4SimHits.initialSeed = 9876
process.RandomNumberGeneratorService.VtxSmeared.initialSeed = 123456789

process.common_beam_direction_parameters = cms.PSet(
    MinE=cms.double(50.0),
    MaxE=cms.double(50.0),
    PartID=cms.vint32(-211),
    MinEta=cms.double(0.2175),
    MaxEta=cms.double(0.2175),
    MinPhi=cms.double(-0.1309),
    MaxPhi=cms.double(-0.1309),
    BeamPosition=cms.double(-800.0))

process.source = cms.Source("EmptySource",
                            firstRun=cms.untracked.uint32(1),
                            firstEvent=cms.untracked.uint32(1))

process.generator = cms.EDProducer(
    "FlatRandomEGunProducer",
    PGunParameters=cms.PSet(process.common_beam_direction_parameters, ),
Пример #45
0
def getHighMultVPSet():
    ret = cms.VPSet()
    thresholds = [60, 85, 110, 135, 160]
    for t in thresholds:
        partialPathName = "HLT_PixelTracks_Multiplicity" + str(t) + "_v"
        tracksL = 0
        tracksH = 200
        tracksBins = (tracksH - tracksL) // 5
        tracksCount = cms.PSet(
            triggerSelection=cms.string(partialPathName + "*"),
            handlerType=cms.string("RecoTrackCounterWithVertexConstraint"),
            inputCol=cms.InputTag("generalTracks"),
            # l parameters
            vtxCollection=cms.InputTag("offlinePrimaryVertices"),
            minNDOF=cms.int32(7),
            maxZ=cms.double(15),
            maxDZ=cms.double(0.12),
            maxDZ2dzsigma=cms.double(3),
            maxDXY=cms.double(0.12),
            maxDXY2dxysigma=cms.double(3),
            partialPathName=cms.string(partialPathName),
            partialFilterName=cms.string("hltL1sETT"),
            #dqmhistolabel  = cms.string("hltPixelTracks"),
            dqmhistolabel=cms.string("recoTracks"),
            mainDQMDirname=cms.untracked.string(fsqdirname),
            singleObjectsPreselection=cms.string("pt > 0.4 && abs(eta) < 2.4"),
            singleObjectDrawables=cms.VPSet(),
            combinedObjectSelection=cms.string("1==1"),
            combinedObjectSortCriteria=cms.string('size()'),
            combinedObjectDimension=cms.int32(1),
            combinedObjectDrawables=cms.VPSet(
                cms.PSet(name=cms.string("count_nominator"),
                         expression=cms.string('at(0)'),
                         bins=cms.int32(tracksBins),
                         min=cms.double(tracksL),
                         max=cms.double(tracksH))))
        ret.append(tracksCount)

        tracksCountDenom = tracksCount.clone(triggerSelection="TRUE")
        tracksCountDenom.combinedObjectDrawables = cms.VPSet(
            cms.PSet(name=cms.string("count_denominator"),
                     expression=cms.string("at(0)"),
                     bins=cms.int32(tracksBins),
                     min=cms.double(tracksL),
                     max=cms.double(tracksH)))
        ret.append(tracksCountDenom)

        hltPixelTracks = cms.PSet(
            triggerSelection=cms.string(partialPathName + "*"),
            handlerType=cms.string("FromHLT"),
            partialPathName=cms.string(partialPathName),
            partialFilterName=cms.string("hlt1HighMult"),
            dqmhistolabel=cms.string("hltPixelTracks"),
            mainDQMDirname=cms.untracked.string(fsqdirname),
            singleObjectsPreselection=cms.string("1==1"),
            singleObjectDrawables=cms.VPSet(
                cms.PSet(name=cms.string("pt"),
                         expression=cms.string("pt"),
                         bins=cms.int32(200),
                         min=cms.double(0.0),
                         max=cms.double(10)),
                cms.PSet(name=cms.string("eta"),
                         expression=cms.string("eta"),
                         bins=cms.int32(100),
                         min=cms.double(-2.5),
                         max=cms.double(2.5)),
                cms.PSet(name=cms.string("phi"),
                         expression=cms.string("phi"),
                         bins=cms.int32(100),
                         min=cms.double(-3.15),
                         max=cms.double(3.15))),
            combinedObjectSelection=cms.string("1==1"),
            combinedObjectSortCriteria=cms.string("at(0).pt"),
            combinedObjectDimension=cms.int32(1),
            combinedObjectDrawables=cms.VPSet())
        ret.append(hltPixelTracks)

        hltPixelTracksEta16to18 = hltPixelTracks.clone(
            singleObjectsPreselection='abs(eta) > 1.6 && abs(eta) < 1.8',
            dqmhistolabel="hltPixelTracksEta16to18")
        for i in hltPixelTracksEta16to18.singleObjectDrawables:
            if i.name == "eta":
                hltPixelTracksEta16to18.singleObjectDrawables.remove(i)

        ret.append(hltPixelTracksEta16to18)

        # FIXME: what variables it makes sense to plot in case of ETT seeds?
        l1 = cms.PSet(triggerSelection=cms.string(partialPathName + "*"),
                      handlerType=cms.string("FromHLT"),
                      partialPathName=cms.string(partialPathName),
                      partialFilterName=cms.string("hltL1sETT"),
                      dqmhistolabel=cms.string("l1"),
                      mainDQMDirname=cms.untracked.string(fsqdirname),
                      singleObjectsPreselection=cms.string("1==1"),
                      singleObjectDrawables=cms.VPSet(),
                      combinedObjectSelection=cms.string("1==1"),
                      combinedObjectSortCriteria=cms.string("at(0).pt"),
                      combinedObjectDimension=cms.int32(1),
                      combinedObjectDrawables=cms.VPSet(
                          cms.PSet(name=cms.string("pt"),
                                   expression=cms.string("at(0).pt"),
                                   bins=cms.int32(256 // 4),
                                   min=cms.double(0),
                                   max=cms.double(256)), ))
        ret.append(l1)

    return ret
Пример #46
0
import FWCore.ParameterSet.Config as cms
from RecoJets.JetProducers.puJetIDParams_cfi import *

####################################################################################################################
full_53x = cms.PSet(
    impactParTkThreshold=cms.double(1.),
    cutBased=cms.bool(False),
    tmvaWeights=cms.string(
        "CondFormats/JetMETObjects/data/TMVAClassificationCategory_JetID_53X_Dec2012.weights.xml"
    ),
    tmvaMethod=cms.string("JetIDMVAHighPt"),
    version=cms.int32(-1),
    tmvaVariables=cms.vstring(
        "nvtx",
        "dZ",
        "beta",
        "betaStar",
        "nCharged",
        "nNeutrals",
        "dR2Mean",
        "ptD",
        "frac01",
        "frac02",
        "frac03",
        "frac04",
        "frac05",
    ),
    tmvaSpectators=cms.vstring("jetPt", "jetEta", "jetPhi"),
    JetIdParams=full_53x_wp,
    label=cms.string("full53x"))
Пример #47
0
def getSinglePFJet(thresholds,
                   flavour=None,
                   etaMin=-1,
                   srcType="genJets",
                   partialPathName="HLT_PFJet",
                   disableEff=False):
    if srcType == "genJets":
        inputCol = cms.InputTag("ak4GenJets")
        handlerType = "FromRecoCandidate"
        label = srcType
    elif srcType == "ak4PFJetsCHS":
        inputCol = cms.InputTag("ak4PFJetsCHS")
        handlerType = "RecoPFJetWithJEC"
        label = srcType
    elif srcType == "hlt":
        inputCol = cms.InputTag("S")
        handlerType = "FromHLT"
        label = srcType
    else:
        raise Exception("Whooops!")

    if etaMin == None:
        etaMin = -1

    ret = cms.VPSet()
    for t in thresholds:
        partialPathNameLoc = partialPathName
        partialPathNameLoc += str(t) + "_"
        if flavour != None:
            partialPathNameLoc += flavour + "_"
        partialPathNameLoc += "v"

        marginLow = max(t - t // 2, 15)
        ptBinLow = max(t - marginLow, 0)
        marginHigh = min(max(t // 2, 20), 50)
        ptBinHigh = t + marginHigh
        ptBins = min(100, ptBinHigh - ptBinLow)
        fromJets = cms.PSet(
            triggerSelection=cms.string(partialPathNameLoc + "*"),
            handlerType=cms.string(handlerType),
            PFJetCorLabel=cms.InputTag("ak4PFL1FastL2L3Corrector"),
            inputCol=inputCol,
            #    inputCol = cms.InputTag("ak4PFJetsCHS"),
            partialPathName=cms.string(partialPathNameLoc),
            partialFilterName=cms.string("hltSinglePFJet"),
            dqmhistolabel=cms.string(label),
            mainDQMDirname=cms.untracked.string(fsqdirname),
            singleObjectsPreselection=cms.string(
                "abs(eta) < 5.5 && abs(eta) > " + str(etaMin)),
            singleObjectDrawables=cms.VPSet(),
            combinedObjectSelection=cms.string("1==1"),
            combinedObjectSortCriteria=cms.string("at(0).pt"),
            combinedObjectDimension=cms.int32(1),
            combinedObjectDrawables=cms.VPSet(
                cms.PSet(name=cms.string("pt"),
                         expression=cms.string("at(0).pt"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)),
                cms.PSet(name=cms.string("eta"),
                         expression=cms.string("at(0).eta"),
                         bins=cms.int32(52),
                         min=cms.double(-5.2),
                         max=cms.double(5.2)),
                cms.PSet(name=cms.string("pt_nominator"),
                         expression=cms.string("at(0).pt"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh))))
        if disableEff:
            for p in fromJets.combinedObjectDrawables:
                if p.name == cms.string("pt_nominator"):
                    fromJets.combinedObjectDrawables.remove(p)
                    break
        else:
            fromJetsDenom = fromJets.clone(triggerSelection="HLT_ZeroBias_v*")
            fromJetsDenom.singleObjectDrawables = cms.VPSet()
            fromJetsDenom.combinedObjectDrawables = cms.VPSet(
                cms.PSet(name=cms.string("pt_denominator"),
                         expression=cms.string("at(0).pt"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)))
            ret.append(fromJetsDenom)
        ret.append(fromJets)
    return ret
     5.50039288E-09   2        24        36   # BR(Hp -> W A0)
DECAY         6     1.37127534E+00   # Gamma(top)
     1.00000000E+00   2         5        24   # BR(top -> bottom W)
"""

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(1),                        
                         filterEfficiency = cms.untracked.double(1),
                         pythiaHepMCVerbosity = cms.untracked.bool(False),
                         SLHATableForPythia8 = cms.string('%s' % SLHA_TABLE),
                         comEnergy = cms.double(COM_ENERGY),
                         crossSection = cms.untracked.double(CROSS_SECTION),                         
                         maxEventsToPrint = cms.untracked.int32(1),
                         PythiaParameters = cms.PSet(
                             pythia8CommonSettingsBlock,
                             pythia8CUEP8M1SettingsBlock,
                             processParameters = cms.vstring(
                                 'Higgs:useBSM = on', 
                                 PROCESS, 
                                 'SLHA:allowUserOverride = off', 
                                 'SLHA:minMassSM = 100.', 
                                 'PhaseSpace:mHatMin = 56.0'
                             ),
                             parameterSets = cms.vstring(
                                 'pythia8CommonSettings',
                                 'pythia8CUEP8M1Settings',
Пример #49
0
def getPTAveVPSet(thresholds=[30, 60, 80, 100, 160, 220, 300],
                  flavour="HFJEC",
                  disableCalo=False):
    # HLT_DiPFJetAve35_HFJEC_v1
    # HLT_DiPFJetAve15_Central_v1
    if flavour == "HFJEC":
        probeEtaSelection = "abs(eta) > 2.7"
        probeEtaSelectionCombined = "abs(at(1).eta) > 2.7"
    elif flavour == "Central":
        probeEtaSelection = "abs(eta) < 2.7"
        probeEtaSelectionCombined = "abs(at(1).eta) < 2.7"
    else:
        raise Exception("Flavour not known " + flavour)
    ret = cms.VPSet()
    for t in thresholds:
        #partialPathName = "HLT_DiPFJetAve"+ str(t) +"_HFJEC_"
        partialPathName = "HLT_DiPFJetAve" + str(t) + "_" + flavour + "_v"

        ptBinLow = t // 2
        ptBinHigh = max(100, t * 2)
        ptBins = min(100, ptBinHigh - ptBinLow)

        if not disableCalo:
            hltCalo = cms.PSet(
                triggerSelection=cms.string(partialPathName + "*"),
                handlerType=cms.string("FromHLT"),
                partialPathName=cms.string(partialPathName),
                partialFilterName=cms.string(
                    "ForHFJECBase"
                ),  # note: this matches to hltSingleCaloJetXXXForHFJECBase
                dqmhistolabel=cms.string("hltCaloJets"),
                mainDQMDirname=cms.untracked.string(fsqdirname),
                singleObjectsPreselection=cms.string("abs(eta)<1.4 || " +
                                                     probeEtaSelection),
                singleObjectDrawables=cms.VPSet(),
                combinedObjectSelection=cms.string("1==1"),
                combinedObjectSortCriteria=cms.string("at(0).pt"),
                combinedObjectDimension=cms.int32(1),
                combinedObjectDrawables=cms.VPSet(
                    cms.PSet(name=cms.string("pt"),
                             expression=cms.string("at(0).pt"),
                             bins=cms.int32(ptBins),
                             min=cms.double(ptBinLow),
                             max=cms.double(ptBinHigh)),
                    cms.PSet(name=cms.string("eta"),
                             expression=cms.string("at(0).eta"),
                             bins=cms.int32(104),
                             min=cms.double(-5.2),
                             max=cms.double(5.2))))
            ret.append(hltCalo)

        l1 = cms.PSet(triggerSelection=cms.string(partialPathName + "*"),
                      handlerType=cms.string("FromHLT"),
                      partialPathName=cms.string(partialPathName),
                      partialFilterName=cms.string("hltL1"),
                      dqmhistolabel=cms.string("l1"),
                      mainDQMDirname=cms.untracked.string(fsqdirname),
                      singleObjectsPreselection=cms.string("1==1"),
                      singleObjectDrawables=cms.VPSet(),
                      combinedObjectSelection=cms.string("1==1"),
                      combinedObjectSortCriteria=cms.string("at(0).pt"),
                      combinedObjectDimension=cms.int32(1),
                      combinedObjectDrawables=cms.VPSet(
                          cms.PSet(name=cms.string("pt"),
                                   expression=cms.string("at(0).pt"),
                                   bins=cms.int32(256 // 4),
                                   min=cms.double(0),
                                   max=cms.double(256)),
                          cms.PSet(name=cms.string("eta"),
                                   expression=cms.string("at(0).eta"),
                                   bins=cms.int32(104 // 4),
                                   min=cms.double(-5.2),
                                   max=cms.double(5.2))))
        ret.append(l1)
        '''
            hltPFSingle  =  cms.PSet(
                triggerSelection = cms.string(partialPathName+"*"),
                handlerType = cms.string("FromHLT"),
                partialPathName = cms.string(partialPathName),
                partialFilterName  = cms.string("hltDiPFJetAve"),
                dqmhistolabel  = cms.string("hltpfsingle"),
                mainDQMDirname = cms.untracked.string(fsqdirname),
                singleObjectsPreselection = cms.string("abs(eta)<1.4 || abs(eta) > 2.7 "),
                singleObjectDrawables =  cms.VPSet(),
                combinedObjectSelection =  cms.string("1==1"),
                combinedObjectSortCriteria = cms.string("at(0).pt"),
                combinedObjectDimension = cms.int32(1),
                combinedObjectDrawables =  cms.VPSet(
                    cms.PSet (name = cms.string("pt"), expression = cms.string("at(0).pt"), bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)),
                    cms.PSet (name = cms.string("eta"), expression = cms.string("at(0).eta"), bins = cms.int32(104), min = cms.double(-5.2), max = cms.double(5.2))
                )
            )
            ret.append(hltPFSingle)
            '''

        hltPFtopology = cms.PSet(
            triggerSelection=cms.string(partialPathName + "*"),
            handlerType=cms.string("FromHLT"),
            partialPathName=cms.string(partialPathName),
            partialFilterName=cms.string("hltDiPFJetAve"),
            dqmhistolabel=cms.string("hltPFJetsTopology"),
            mainDQMDirname=cms.untracked.string(fsqdirname),
            singleObjectsPreselection=cms.string("abs(eta)<1.4 || " +
                                                 probeEtaSelection),
            singleObjectDrawables=cms.VPSet(),
            combinedObjectSelection=cms.string(
                "abs(at(0).eta())< 1.4 && " + probeEtaSelectionCombined +
                " && abs(deltaPhi(at(0).phi, at(1).phi)) > 2.5"),
            combinedObjectSortCriteria=cms.string("(at(0).pt+at(1).pt)/2"),
            combinedObjectDimension=cms.int32(2),
            combinedObjectDrawables=cms.VPSet(
                cms.PSet(name=cms.string("deltaEta"),
                         expression=cms.string("abs(at(0).eta-at(1).eta)"),
                         bins=cms.int32(70),
                         min=cms.double(0),
                         max=cms.double(7)),
                cms.PSet(name=cms.string("deltaPhi"),
                         expression=cms.string(
                             "abs(deltaPhi(at(0).phi, at(1).phi))"),
                         bins=cms.int32(100),
                         min=cms.double(0),
                         max=cms.double(3.2)),
                cms.PSet(name=cms.string("ptAve"),
                         expression=cms.string("(at(0).pt+at(1).pt)/2"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)),
                cms.PSet(
                    name=cms.string("ptTag"),
                    expression=cms.string(
                        "? abs(at(0).eta) < abs(at(1).eta) ? at(0).pt : at(1).pt "
                    ),
                    bins=cms.int32(ptBins),
                    min=cms.double(ptBinLow),
                    max=cms.double(ptBinHigh)),
                cms.PSet(
                    name=cms.string("ptProbe"),
                    expression=cms.string(
                        "? abs(at(0).eta) < abs(at(1).eta) ? at(1).pt : at(0).pt "
                    ),
                    bins=cms.int32(ptBins),
                    min=cms.double(ptBinLow),
                    max=cms.double(ptBinHigh))))
        ret.append(hltPFtopology)
        '''
            # FromJet
            recoThr = t
            recoPF  =  cms.PSet(
                triggerSelection = cms.string(partialPathName+"*"),
                handlerType = cms.string("FromRecoCandidate"),
                inputCol = cms.InputTag("ak4PFJetsCHS"),
                partialPathName = cms.string(partialPathName),
                partialFilterName  = cms.string("hltDiPFJetAve"),
                dqmhistolabel  = cms.string("recoJet"),
                mainDQMDirname = cms.untracked.string(fsqdirname),
                singleObjectsPreselection = cms.string("pt > + "+str(recoThr) +" && (abs(eta)<1.3 || abs(eta) > 2.8) "),
                singleObjectDrawables =  cms.VPSet(),
                combinedObjectSelection =  cms.string("1==1"),
                combinedObjectSortCriteria = cms.string("at(0).pt"),
                combinedObjectDimension = cms.int32(1),
                combinedObjectDrawables =  cms.VPSet(
                    cms.PSet (name = cms.string("pt"), expression = cms.string("at(0).pt"), bins = cms.int32(ptBins), min = cms.double(ptBinLow), max = cms.double(ptBinHigh)),
                    cms.PSet (name = cms.string("eta"), expression = cms.string("at(0).eta"), bins = cms.int32(52), min = cms.double(-5.2), max = cms.double(5.2))
                )
            )
            ret.append(recoPF) 
            '''
        recoThr = t // 2
        recoPFtopology = cms.PSet(
            triggerSelection=cms.string(partialPathName + "*"),
            handlerType=cms.string("RecoPFJetWithJEC"),
            PFJetCorLabel=cms.InputTag("ak4PFL1FastL2L3Corrector"),
            inputCol=cms.InputTag("ak4PFJetsCHS"),
            partialPathName=cms.string(partialPathName),
            partialFilterName=cms.string("hltDiPFJetAve"),
            dqmhistolabel=cms.string("recoPFJetsTopology"),
            mainDQMDirname=cms.untracked.string(fsqdirname),
            singleObjectsPreselection=cms.string("pt > " + str(recoThr) +
                                                 " && (abs(eta)<1.4 ||" +
                                                 probeEtaSelection + ")"),
            singleObjectDrawables=cms.VPSet(),
            combinedObjectSelection=cms.string(
                "abs(at(0).eta())< 1.3 && " + probeEtaSelectionCombined +
                " && abs(deltaPhi(at(0).phi, at(1).phi)) > 2.5"),
            combinedObjectSortCriteria=cms.string("(at(0).pt+at(1).pt)/2"),
            combinedObjectDimension=cms.int32(2),
            combinedObjectDrawables=cms.VPSet(
                cms.PSet(name=cms.string("deltaEta"),
                         expression=cms.string("abs(at(0).eta-at(1).eta)"),
                         bins=cms.int32(70),
                         min=cms.double(0),
                         max=cms.double(7)),
                cms.PSet(name=cms.string("deltaPhi"),
                         expression=cms.string(
                             "abs(deltaPhi(at(0).phi, at(1).phi))"),
                         bins=cms.int32(100),
                         min=cms.double(0),
                         max=cms.double(3.2)),
                cms.PSet(name=cms.string("ptAve"),
                         expression=cms.string("(at(0).pt+at(1).pt)/2"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)),
                cms.PSet(
                    name=cms.string("ptTag"),
                    expression=cms.string(
                        "?  abs(at(0).eta) < abs(at(1).eta) ? at(0).pt : at(1).pt "
                    ),
                    bins=cms.int32(ptBins),
                    min=cms.double(ptBinLow),
                    max=cms.double(ptBinHigh)),
                cms.PSet(
                    name=cms.string("ptProbe"),
                    expression=cms.string(
                        "?  abs(at(0).eta) < abs(at(1).eta) ? at(1).pt : at(0).pt "
                    ),
                    bins=cms.int32(ptBins),
                    min=cms.double(ptBinLow),
                    max=cms.double(ptBinHigh)),
                cms.PSet(name=cms.string("ptAve_nominator"),
                         expression=cms.string("(at(0).pt+at(1).pt)/2"),
                         bins=cms.int32(ptBins),
                         min=cms.double(ptBinLow),
                         max=cms.double(ptBinHigh)),
            ))
        ret.append(recoPFtopology)
        recoPFtopologyDenom = recoPFtopology.clone(
            #triggerSelection = "HLTriggerFirstPath*",
            #triggerSelection = partialPathName+"*",
            triggerSelection="TRUE")
        recoPFtopologyDenom.combinedObjectDrawables = cms.VPSet(
            cms.PSet(name=cms.string("ptAve_denominator"),
                     expression=cms.string("(at(0).pt+at(1).pt)/2"),
                     bins=cms.int32(ptBins),
                     min=cms.double(ptBinLow),
                     max=cms.double(ptBinHigh)))
        ret.append(recoPFtopologyDenom)

        # RecoCandidateCounter
        ''' example on how to count objects
            recoThr = t//2
            recoPFJetCnt  =  cms.PSet(
                triggerSelection = cms.string(partialPathName+"*"),
                handlerType = cms.string("RecoCandidateCounter"),
                inputCol = cms.InputTag("ak4PFJetsCHS"),
                partialPathName = cms.string(partialPathName),
                partialFilterName  = cms.string("hltDiPFJetAve"),
                dqmhistolabel  = cms.string("recoPFJetsCnt"),
                mainDQMDirname = cms.untracked.string(fsqdirname),
                singleObjectsPreselection = cms.string("pt >  "+str(recoThr) +" && abs(eta)<1.4 || abs(eta) > 2.7 "),
                singleObjectDrawables =  cms.VPSet(),
                combinedObjectSelection =  cms.string("1==1"),
                combinedObjectSortCriteria = cms.string('size()'),
                combinedObjectDimension = cms.int32(1),
                combinedObjectDrawables =  cms.VPSet(
                    cms.PSet (name = cms.string("count"), expression = cms.string('at(0)'), 
                             bins = cms.int32(30), min = cms.double(0), max = cms.double(30))
                )
            )
            ret.append(recoPFJetCnt)
            '''

    return ret
Пример #50
0
import FWCore.ParameterSet.Config as cms

from Configuration.Generator.Pythia8CommonSettings_cfi import *
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *

generator = cms.EDFilter("Pythia8GeneratorFilter",
                         maxEventsToPrint=cms.untracked.int32(1),
                         pythiaPylistVerbosity=cms.untracked.int32(1),
                         filterEfficiency=cms.untracked.double(1.0),
                         pythiaHepMCVerbosity=cms.untracked.bool(False),
                         comEnergy=cms.double(13000.),
                         PythiaParameters=cms.PSet(
                             pythia8CommonSettingsBlock,
                             pythia8CUEP8M1SettingsBlock,
                             processParameters=cms.vstring(
                                 'ExcitedFermion:qqbar2tauStartau = on',
                                 'ExcitedFermion:Lambda= 10000',
                                 '4000015:onMode = off',
                                 '4000015:onIfMatch = 15 22',
                                 '4000015:m0 = 3250'),
                             parameterSets=cms.vstring(
                                 'pythia8CommonSettings',
                                 'pythia8CUEP8M1Settings',
                                 'processParameters',
                             )))
Пример #51
0
import FWCore.ParameterSet.Config as cms
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(1),
    filterEfficiency=cms.untracked.double(0.056),
    crossSection=cms.untracked.double(1189000.),
    comEnergy=cms.double(8000.0),  # center of mass energy in GeV
    PythiaParameters=cms.PSet(pythia8CommonSettingsBlock,
                              pythia8CUEP8M1SettingsBlock,
                              processParameters=cms.vstring(
                                  'HardQCD:all = on',
                                  'PhaseSpace:pTHatMin = 80.',
                                  'PhaseSpace:pTHatMax = 170.'),
                              parameterSets=cms.vstring(
                                  'pythia8CommonSettings',
                                  'pythia8CUEP8M1Settings',
                                  'processParameters',
                              )))

# if you need some filter modules define and configure them here
genParticlesForFilter = cms.EDProducer(
    "GenParticleProducer",
    saveBarCodes=cms.untracked.bool(True),
    src=cms.InputTag("generator"),
    abortOnUnknownPDGCode=cms.untracked.bool(True))
Пример #52
0
                                   1, 8, 9, 10,
                                   11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
                                   22, 24, 26, 28, 30, 32, 34, 36, 38, 40,
                                   45, 50, 55, 60, 65, 70,
                                   80, 100,
                                   ),

    # -- (NBins, minVal, maxValue) for the Eta,Phi and nInterations efficiency plots
    parametersEta      = cms.vdouble(48, -2.400, 2.400),
    parametersPhi      = cms.vdouble(50, -3.142, 3.142),
    parametersPu       = cms.vdouble(10, 0, 20),

    # TO BE DEPRECATED --------------------------------------------
    cutsDr = cms.vdouble(0.4, 0.4, 0.015), # TO BE DEPRECATED
    # parameters for attempting an L1 match using a propagator
    maxDeltaPhi = cms.double(0.4),  # TO BE DEPRECATED
    maxDeltaR   = cms.double(0.4),  # TO BE DEPRECATED
    # TO BE DEPRECATED --------------------------------------------

    # Definition of generic cuts on generated and reconstructed objects (note that
    # these cuts can be overloaded inside a particular analysis)
    # Objects recognized: Mu Ele Photon PFTau MET
    # Syntax in the strings: valid syntax of the StringCutObjectSelector class
    # --- Muons
    Mu_genCut     = cms.string("pt > 10 && abs(eta) < 2.4 && abs(pdgId) == 13 && status == 1"),
    Mu_recCut     = cms.string("pt > 10 && abs(eta) < 2.4 && isGlobalMuon"),
    Mu_cutMinPt   = cms.double(10),  # TO BE DEPRECATED
    Mu_cutMaxEta  = cms.double(2.4), # TO BE DEPRECATED
    
    # --- Electrons
    Ele_genCut      = cms.string("pt > 10 && abs(eta) < 2.5 && abs(pdgId) == 11 && status == 1"),
import FWCore.ParameterSet.Config as cms

from Configuration.Generator.Pyquen2016TmpSettingsEv4_cff import *

generator = cms.EDFilter("HydjetGeneratorFilter",
                         collisionParameters5020GeV,
                         qgpParameters,
                         hydjetParameters,
                         hydjetMode = cms.string('kHydroQJets'),
                         PythiaParameters = cms.PSet(pyquenPythiaDefaultBlock,
                                                     # Quarkonia and Weak Bosons added back upon dilepton group's request.
                                                     parameterSets = cms.vstring('pythiaUESettings',
                                                                                 'hydjetPythiaDefault',
                                                                                 'myParameters',
                                                                                 'pythiaJets',
                                                                                 'pythiaPromptPhotons',
                                                                                 'pythiaZjets',
                                                                                 'pythiaBottomoniumNRQCD',
                                                                                 'pythiaCharmoniumNRQCD',
                                                                                 'pythiaQuarkoniaSettings',
                                                                                 'pythiaWeakBosons'
                                                                                 )
                                                     ),
                         cFlag = cms.int32(1),
                         bMin = cms.double(0),
                         bMax = cms.double(30),
                         bFixed = cms.double(0)
                         )
		descriptors = cms.vstring()
	),
	cms.PSet(
		name        = cms.string("MinSubleadingPFJetPt"),
		parameters  = cms.vdouble(70.),
		descriptors = cms.vstring()
	),
	cms.PSet(
		name        = cms.string("PFDijetMaxDeltaEta"),
		parameters  = cms.vdouble(1.3),
		descriptors = cms.vstring()
	)
)

##-------------------- User analyzer  --------------------------------
process.BHistograms    = cms.EDAnalyzer('BTriggerEfficiency',
	file_names             = input_files_vstring,
	tree_name              = cms.string('ak5/ProcessedTree'),
	trigger_histogram_name = cms.string('ak5/TriggerNames'),
	data_source            = cms.string('collision_data'),    
	max_events             = cms.int32(-1),
	dijet_cuts             = dijet_cuts,
	pfjet_cuts             = pfjet_cuts,
	calojet_cuts           = calojet_cuts,
	event_cuts             = event_cuts,
	fatjet_delta_eta_cut   = cms.double(1.1),
)

process.p = cms.Path(process.BHistograms)

Пример #55
0
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_32.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_320.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_321.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_322.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_323.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_324.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_325.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_326.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_327.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_328.root',
        '/store/user/tuos/HIAOD2015/round3/June01/HydjetMB/Hydjet_Quenched_MinBias_5020GeV/HydjetMB_AOD_750pre5_round3v01/150601_223002/0000/step2_RAW2DIGI_L1Reco_MB_AODSIM_329.root'
    ))

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

process.demo = cms.EDAnalyzer(
    'TestAnalysis',
    CentralitySrc=cms.InputTag("hiCentrality"),
    centralityBinLabel=cms.InputTag("centralityBin", "HFtowers"),
    srcTracks=cms.InputTag("hiGeneralTracks"),
    srcVertex=cms.InputTag("hiSelectedVertex"),
    UseQuality=cms.bool(True),
    TrackQuality=cms.string('highPurity'),
    trackEtaCut=cms.double(2.4),
    trackPtCut=cms.double(0.3),
    srcTracksPixel=cms.InputTag("hiGeneralAndPixelTracks"))

process.p = cms.Path(process.centralityBin * process.demo)
Пример #56
0
    addDiscriminators = True,
    addAssociatedTracks = True,
    addJetCharge = False,
    addJetID = False,
    getJetMCFlavour = True,
    addGenPartonMatch = True,
    addGenJetMatch = True,
    embedGenJetMatch = True,
    embedGenPartonMatch = True,
    # embedCaloTowers = False,
    # embedPFCandidates = True
    )

akSoftDrop6PFNjettiness = Njettiness.clone(
    src = cms.InputTag("akSoftDrop6PFJets"),
    R0  = cms.double(0.6)
    )

akSoftDrop6PFpatJetsWithBtagging.userData.userFloats.src += [
    'akSoftDrop6PFNjettiness:tau1',
    'akSoftDrop6PFNjettiness:tau2',
    'akSoftDrop6PFNjettiness:tau3']

akSoftDrop6PFJetAnalyzer = inclusiveJetAnalyzer.clone(
    jetTag = cms.InputTag("akSoftDrop6PFpatJetsWithBtagging"),
    genjetTag = 'ak6GenJets',
    rParam = 0.6,
    matchJets = cms.untracked.bool(False),
    matchTag = 'patJetsWithBtagging',
    pfCandidateLabel = cms.untracked.InputTag('particleFlow'),
    trackTag = cms.InputTag("generalTracks"),
from ForwardAnalysis.Utilities.trackMultiplicity_cfi import *
trackMultiplicityTransverseRegion = trackMultiplicity.clone(
    src="tracksTransverseRegion")

#
# Systematic Studies
#

pfCandidatesShiftedUp = cms.EDProducer(
    "ShiftedPFCandidateProducer",
    src=cms.InputTag('particleFlow'),
    binning=cms.VPSet(
        cms.PSet(
            binSelection=cms.string('particleId == 0'),  # particleId == X
            binUncertainty=cms.double(0.10)),
        cms.PSet(
            binSelection=cms.string('particleId == 1'),  # particleId == h
            binUncertainty=cms.double(0.10)),
        cms.PSet(
            binSelection=cms.string('particleId == 2'),  # particleId == e
            binUncertainty=cms.double(0.10)),
        cms.PSet(
            binSelection=cms.string('particleId == 3'),  # particleId == mu
            binUncertainty=cms.double(0.10)),
        cms.PSet(
            binSelection=cms.string('particleId == 4'),  # particleId == gamma
            binUncertainty=cms.double(0.10)),
        cms.PSet(
            binSelection=cms.string('particleId == 5'),  # particleId == h0
            binUncertainty=cms.double(0.10)),
    CrossingAngle=TPCrossingAngle,
    BeamLineLengthCTPPS=TPBeamLineLengthCTPPS,
    #CTPPSSimHitProducer
    Z_Tracker1=ZTracker1Position,  # first tracker z position in m
    Z_Tracker2=ZTracker2Position,
    Z_Timing=ZTimingPosition,
    #CTPPSRecHitProducer
    TrackerWidth=RecTrackerWidth,
    TrackerHeight=RecTrackerHeight,  # tracker height in mm
    TrackerInsertion=
    RecTrackerInsertion,  # Number of sigmas (X) from the beam for tracker insertion
    BeamXRMS_Trk1=
    RecBeamXRMS_Trk1,  # beam size sigma(X) at first tracker station in mm
    BeamXRMS_Trk2=
    RecBeamXRMS_Trk2,  # beam size sigma(X) at second tracker station in mm
    Trk1XOffset=RecTrk1XOffset,  # insertion offset first tracker
    Trk2XOffset=RecTrk2XOffset,  # insertion offset second tracker
    ToFCellWidth=RecToFCellWidth,  #tofcell widths in mm - diamond  
    ToFCellHeight=RecToFCellHeight,  #tof height in mm
    ToFPitchX=RecToFPitchX,  #cell pitch in X (in mm)
    ToFPitchY=RecToFPitchY,  #cell pitch in Y (in mm)
    ToFNCellX=RecToFNCellX,  # number of cells in X
    ToFNCellY=RecToFNCellY,  # number of cells in Y
    ToFInsertion=
    RecToFInsertion,  #Number of sigmas (X) from the beam for the tof insertion
    BeamXRMS_ToF=RecBeamXRMS_ToF,  #beam size sigma(X) at ToF station in mm
    ToFXOffset=RecToFXOffset,  #insertion offset ToF
    TimeSigma=RecTimeSigma,  #in ns
    #
    ImpParcut=cms.double(0.6))
Пример #59
0
    0.00000000E+00  3    1000022    2   -1    #dummy decay to enable off-shell W
    0.33333333E+00  2    -1000011    12
    0.33333333E+00  2    -1000013    14
    0.33333333E+00  2    -1000015    16
DECAY   1000025     0.00000000E+00   # neutralino3 decays
DECAY   1000035     0.00000000E+00   # neutralino4 decays
DECAY   1000037     0.00000000E+00   # chargino2+ decays
"""

generator = cms.EDFilter(
    "Pythia8GeneratorFilter",
    maxEventsToPrint=cms.untracked.int32(1),
    pythiaPylistVerbosity=cms.untracked.int32(1),
    filterEfficiency=cms.untracked.double(1.0),
    pythiaHepMCVerbosity=cms.untracked.bool(False),
    comEnergy=cms.double(13000.),
    RandomizedParameters=cms.VPSet(),
)

model = "T8bbllnunu_XCha0p5"

# weighted average of matching efficiencies for the full scan
# must equal the number entered in McM generator params
mcm_eff = 0.277


def matchParams(mass):
    if mass > 99 and mass < 199: return 62., 0.498
    elif mass < 299: return 62., 0.361
    elif mass < 399: return 62., 0.302
    elif mass < 499: return 64., 0.275
Пример #60
0
    VCaltoElectronGain_L1=cms.int32(65),
    VCaltoElectronOffset=cms.int32(-414),
    VCaltoElectronOffset_L1=cms.int32(-414),
    # **************************************
    # ****  payLoadType Options         ****
    # ****  HLT - column granularity    ****
    # ****  Offline - gain:col/ped:pix  ****
    # **************************************
    payloadType=cms.string('Offline'),
    #payloadType = cms.string('Full'),
    SeedThreshold=cms.int32(1000),
    ClusterThreshold=cms.int32(4000),
    ClusterThreshold_L1=cms.int32(4000),
    # **************************************
    maxNumberOfClusters=cms.int32(-1),  # -1 means no limit.
    ElectronPerADCGain=cms.double(135.0),
    AdcFullScaleStack=cms.int32(255),
    FirstStackLayer=cms.int32(5),
    Phase2Calibration=cms.bool(False),
    Phase2ReadoutMode=cms.int32(-1),
    Phase2DigiBaseline=cms.double(1200.),
    Phase2KinkADC=cms.int32(8),
)

# phase1 pixel
from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
phase1Pixel.toModify(
    siPixelClusters,
    VCaltoElectronGain=cms.int32(47),  # L2-4: 47 +- 4.7
    VCaltoElectronGain_L1=cms.int32(50),  # L1:   49.6 +- 2.6
    VCaltoElectronOffset=cms.int32(-60),  # L2-4: -60 +- 130