Пример #1
0
def customiseFor19181_pixel_phase0(process):
    for producer in producers_by_type(process, "SiPixelClusterProducer"):
        producer.VCaltoElectronGain_L1 = cms.int32(65)
        producer.VCaltoElectronOffset_L1 = cms.int32(-414)
        producer.ClusterThreshold    = cms.int32(4000)
        producer.ClusterThreshold_L1 = cms.int32(4000)
    return process
Пример #2
0
def electronTriggerMatchPT(process,triggerProcess):

   process.triggeredPatElectronsL = cms.EDProducer("ElectronTriggerMatcher",
                                            src = cms.InputTag("cleanPatElectrons"),
                                            trigEvent = cms.InputTag("hltTriggerSummaryAOD"),
                                            filters = cms.VInputTag(
                                                cms.InputTag('hltEle17CaloIdLCaloIsoVLPixelMatchFilterDoubleEG125','',triggerProcess),
                                            ),
                                            pdgId = cms.int32(0)
   )
   process.triggeredPatElectrons = cms.EDProducer("ElectronTriggerMatcher",
                                            src = cms.InputTag("triggeredPatElectronsL"),
                                            trigEvent = cms.InputTag("hltTriggerSummaryAOD"),
                                            filters = cms.VInputTag(
                                                cms.InputTag('hltOverlapFilterIsoEle15IsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle15TightIsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle18MediumIsoPFTau20','',triggerProcess),                                                
                                                cms.InputTag('hltOverlapFilterIsoEle18TightIsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle18IsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle20MediumIsoPFTau20','',triggerProcess)
                                            ),
                                            pdgId = cms.int32(11)
   )
   
   process.analysisSequence=cms.Sequence(process.analysisSequence*process.triggeredPatElectronsL*process.triggeredPatElectrons)
def customizeTSGForOIWithPropagator(process):
	process.hltIterL3OISeedsFromL2Muons = cms.EDProducer( "TSGForOI",
	    hitsToTry = cms.int32( 3 ),
	    adjustErrorsDynamicallyForHitless = cms.bool( True ),
	    SF4 = cms.double( 7.0 ),
	    SF5 = cms.double( 10.0 ),
	    SF2 = cms.double( 4.0 ),
	    SF3 = cms.double( 5.0 ),
	    SF1 = cms.double( 3.0 ),
	    minEtaForTEC = cms.double( 0.7 ),
	    fixedErrorRescaleFactorForHits = cms.double( 3.0 ),
	    maxSeeds = cms.uint32( 5 ),
	    maxEtaForTOB = cms.double( 1.8 ),
	    pT3 = cms.double( 70.0 ),
	    pT2 = cms.double( 30.0 ),
	    pT1 = cms.double( 13.0 ),
	    layersToTry = cms.int32( 2 ),
	    fixedErrorRescaleFactorForHitless = cms.double( 10.0 ),
	    MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ),
	    adjustErrorsDynamicallyForHits = cms.bool( True ),
	    src = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ),
	    tsosDiff = cms.double( 0.03 ),
	    eta1 = cms.double( 1.0 ),
	    eta2 = cms.double( 1.4 ),
	    UseHitLessSeeds = cms.bool( True ),
	    UseStereoLayersInTEC = cms.bool( False ),
	    estimator = cms.string( "hltESPChi2MeasurementEstimator100" ),
	    debug = cms.untracked.bool( False ),
            propagatorAlongName = cms.string( "PropagatorWithMaterial" ),
            propagatorOppositeName = cms.string( "PropagatorWithMaterial" ),
            propagatorHitlessName = cms.string( "PropagatorWithMaterial" ),
            propagatorHitBasedName = cms.string( "PropagatorWithMaterial" ),
	)
def customise_HcalPhase2(process):
    process = customise_HcalPhase1(process)
    if hasattr(process,'digitisation_step') and hasattr(process, 'mix'):

        # these are the new sampling factors,  they reuse the old ones for
        # ieta < 21.  For ieta greater than 21 it is using the function
        # samplingFraction = 188.441 + 0.834*eta
        # eta is the highest eta broundary of the ieta.  This is currently
        # taken for HE from ieta 16 to 33 inclusive.  Which would extend to
        # an eta of 3.0.  For the option going to 4.0 it is unclear how many
        # ieta's there will be from 3 to 4, but this vector would need to be
        # extended.
        newFactors = cms.vdouble(
            210.55, 197.93, 186.12, 189.64, 189.63,
            189.96, 190.03, 190.11, 190.18, 190.25,
            190.32, 190.40, 190.47, 190.54, 190.61,
            190.69, 190.83, 190.94, 190.94, 190.94,
            190.94, 190.94, 190.94, 190.94, 190.94,
            190.94, 190.94, 190.94, 190.94, 190.94,
            190.94, 190.94, 190.94, 190.94, 190.94,
            190.94, 190.94, 190.94, 190.94, 190.94)
        process.mix.digitizers.hcal.he.samplingFactors = newFactors
        process.mix.digitizers.hcal.he.photoelectronsToAnalog = cms.vdouble([10.]*len(newFactors))

    if hasattr(process,'reconstruction_step'):
        process.towerMaker.HcalPhase = cms.int32(2)
        process.towerMakerPF.HcalPhase = cms.int32(2)
        process.towerMakerWithHO.HcalPhase = cms.int32(2)
        process.CaloTowerConstituentsMapBuilder.MapFile = cms.untracked.string("")

    return process
Пример #5
0
def customise_Digi(process):
    process=digiEventContent(process)
    process.mix.digitizers.hcal.ho.photoelectronsToAnalog = cms.vdouble([4.0]*16)
    process.mix.digitizers.hcal.ho.siPMCode = cms.int32(1)
    process.mix.digitizers.hcal.ho.pixels = cms.int32(2500)
    process.mix.digitizers.hcal.ho.doSiPMSmearing = cms.bool(False)
    return process
def eleMomentumRegression(process, datasetpath, datatype):
    # generate hash from datasetpath and form unique but constant seed for each sample
    # !!! WARNING: seed is still dependent on job splitting !!!
    to_hash = datasetpath
    hash_input = to_hash.split("=")[1].strip()
    generate_hash = hashlib.md5(hash_input)
    seed = abs(int(str(int(generate_hash.hexdigest(),16))[0:9])) # crab expects uint32 -> only up to 9 digits of hash can be safely used
    
    process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
                                                       calibratedElectrons = cms.PSet(
                                                       initialSeed = cms.untracked.uint32(seed),
                                                       engineName = cms.untracked.string("TRandom3")
                                                                                     ),
                                                      )
    process.load("EgammaAnalysis.ElectronTools.calibratedElectrons_cfi")
    if datatype == "Data" or "embedded" in datatype:
        process.calibratedElectrons.isMC = cms.bool(False)
        process.calibratedElectrons.inputDataset = cms.string("22Jan2013ReReco")
    else:
        process.calibratedElectrons.isMC = cms.bool(True)
        process.calibratedElectrons.inputDataset = cms.string("Summer12_LegacyPaper")
    process.calibratedElectrons.updateEnergyError = cms.bool(True)
    process.calibratedElectrons.correctionsType = cms.int32(2)
    process.calibratedElectrons.combinationType = cms.int32(3)
    process.calibratedElectrons.applyLinearityCorrection = cms.bool(True)
    
    process.load('EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi')
    process.eleRegressionEnergy.inputElectronsTag = cms.InputTag('gsfElectrons')
    process.eleRegressionEnergy.inputCollectionType = cms.uint32(0)
    process.eleRegressionEnergy.useRecHitCollections = cms.bool(True)
    process.eleRegressionEnergy.produceValueMaps = cms.bool(True)
    process.eleRegressionEnergy.regressionInputFile = cms.string("EgammaAnalysis/ElectronTools/data/eleEnergyRegWeights_WithSubClusters_VApr15.root")
    process.eleRegressionEnergy.energyRegressionType = cms.uint32(2)
Пример #7
0
def customise(process):

    # From python/simEmtfDigis_cfi.py
    if hasattr(process, 'simEmtfDigis'):
        process.simEmtfDigis.spPCParams16.ZoneBoundaries = [0,36,54,96,127]
        process.simEmtfDigis.spPCParams16.UseNewZones    = True
        process.simEmtfDigis.RPCEnable                   = True
        process.simEmtfDigis.GEMEnable                   = True
        process.simEmtfDigis.IRPCEnable                  = True
        process.simEmtfDigis.ME0Enable                   = True
        process.simEmtfDigis.TTEnable                    = False
        process.simEmtfDigis.ME0Input                    = cms.InputTag('fakeSimMuonME0PadDigis')
        process.simEmtfDigis.Era                         = cms.string('Phase2C2')
        process.simEmtfDigis.spPAParams16.PtLUTVersion   = cms.int32(7)

    # From python/fakeEmtfParams_cff.py
    if hasattr(process, 'emtfParams'):
        process.emtfParams.PtAssignVersion = cms.int32(7)

    if hasattr(process, 'emtfForestsDB'):
        process.emtfForestsDB = cms.ESSource(
            "EmptyESSource",
            recordName = cms.string('L1TMuonEndCapForestRcd'),
            iovIsRunNotTime = cms.bool(True),
            firstValid = cms.vuint32(1)
            )

        process.emtfForests = cms.ESProducer(
            "L1TMuonEndCapForestESProducer",
            PtAssignVersion = cms.int32(7),
            bdtXMLDir = cms.string("2017_v7")
            )

    return process
Пример #8
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
Пример #9
0
def _modifyPixelDigitizerForPhase1Pixel( digitizer ) :
    """
    Function that modifies the pixel digitiser for the Phase 1 pixel detector.
    
    First argument is the pixelDigitizer object.
    """
    #use default switches, new analog respnse, d.k. 2/16
    #digitizer.MissCalibrate = False
    #digitizer.LorentzAngle_DB = False
    #digitizer.killModules = False
    #digitizer.useDB = False
    #digitizer.DeadModules_DB = False
    digitizer.NumPixelBarrel = cms.int32(4)
    digitizer.NumPixelEndcap = cms.int32(3)
    digitizer.ThresholdInElectrons_FPix = cms.double(2000.0)
    digitizer.ThresholdInElectrons_BPix = cms.double(2000.0)
    digitizer.ThresholdInElectrons_BPix_L1 = cms.double(2000.0)
    digitizer.FPix_SignalResponse_p0 = cms.double(0.00171)
    digitizer.FPix_SignalResponse_p1 = cms.double(0.711)
    digitizer.FPix_SignalResponse_p2 = cms.double(203.)
    digitizer.FPix_SignalResponse_p3 = cms.double(148.)
    digitizer.BPix_SignalResponse_p0 = cms.double(0.00171)
    digitizer.BPix_SignalResponse_p1 = cms.double(0.711)
    digitizer.BPix_SignalResponse_p2 = cms.double(203.)
    digitizer.BPix_SignalResponse_p3 = cms.double(148.)
def customise_Validation(process,pileup):
    process.validation_step.remove(process.PixelTrackingRecHitsValid)
    process.validation_step.remove(process.stripRecHitsValid)
    process.validation_step.remove(process.trackerHitsValid)
    process.validation_step.remove(process.StripTrackingRecHitsValid)
    # We don't run the HLT
    process.validation_step.remove(process.HLTSusyExoVal)
    process.validation_step.remove(process.hltHiggsValidator)
    process.validation_step.remove(process.relvalMuonBits)
    if pileup>30:
        process.trackValidator.label=cms.VInputTag(cms.InputTag("cutsRecoTracksHp"))
        process.tracksValidationSelectors = cms.Sequence(process.cutsRecoTracksHp)
        process.globalValidation.remove(process.recoMuonValidation)
        process.validation.remove(process.recoMuonValidation)
        process.validation_preprod.remove(process.recoMuonValidation)
        process.validation_step.remove(process.recoMuonValidation)
        process.validation.remove(process.globalrechitsanalyze)
        process.validation_prod.remove(process.globalrechitsanalyze)
        process.validation_step.remove(process.globalrechitsanalyze)
        process.validation.remove(process.stripRecHitsValid)
        process.validation_step.remove(process.stripRecHitsValid)
        process.validation_step.remove(process.StripTrackingRecHitsValid)
        process.globalValidation.remove(process.vertexValidation)
        process.validation.remove(process.vertexValidation)
        process.validation_step.remove(process.vertexValidation)
        process.mix.input.nbPileupEvents.averageNumber = cms.double(0.0)
        process.mix.minBunch = cms.int32(0)
        process.mix.maxBunch = cms.int32(0)

    if hasattr(process,'simHitTPAssocProducer'):    
        process.simHitTPAssocProducer.simHitSrc=cms.VInputTag(cms.InputTag("g4SimHits","TrackerHitsPixelBarrelLowTof"),
                                                              cms.InputTag("g4SimHits","TrackerHitsPixelEndcapLowTof"))

    return process
Пример #11
0
def addCategory(pset,label,cutbased=None,subcats=0,variables=[],histograms=[],mvas=None,classname=None,binnedOnly=None,
                dumpPdfWeights=None,nPdfWeights=None,nAlphaSWeights=None,nScaleWeights=None,splitPdfByStage0Cat=None):
    
   
    if subcats >= 0:
        catDef = cms.PSet(label=cms.string(label),
                          subcats=cms.int32(subcats),
                          variables=cms.VPSet(),
                          histograms=cms.VPSet(),
                          )
        if classname: catDef.className=cms.string(classname)
        if binnedOnly: catDef.binnedOnly=cms.bool(binnedOnly)
        if dumpPdfWeights: catDef.dumpPdfWeights=cms.bool(dumpPdfWeights)
        if nPdfWeights: catDef.nPdfWeights=cms.int32(nPdfWeights)
        if nAlphaSWeights: catDef.nAlphaSWeights=cms.int32(nAlphaSWeights)
        if nScaleWeights: catDef.nScaleWeights=cms.int32(nScaleWeights)
        if splitPdfByStage0Cat is not None: catDef.splitPdfByStage0Cat=cms.bool(splitPdfByStage0Cat)
        

        addVariables( catDef.variables, variables )
        addHistograms( catDef.histograms, histograms  )
        if mvas: 
            catDef.mvas = cms.VPSet()
            addMVAs( catDef.mvas, mvas  )
        
        pset.categories.append(catDef)

    if cutbased:
        cb = cms.PSet( cut=cms.string(cutbased) )
        if( label != "" or classname):
            cb.name = cms.untracked.string(label)
        pset.classifierCfg.categories.append(cb)
def customise_Digi(process):
    process.mix.digitizers.pixel.MissCalibrate = False
    process.mix.digitizers.pixel.LorentzAngle_DB = False
    process.mix.digitizers.pixel.killModules = False
    process.mix.digitizers.pixel.useDB = False
    process.mix.digitizers.pixel.DeadModules_DB = False
    process.mix.digitizers.pixel.NumPixelBarrel = cms.int32(10)
    process.mix.digitizers.pixel.NumPixelEndcap = cms.int32(7)
    process.mix.digitizers.pixel.ThresholdInElectrons_FPix = cms.double(2000.0)
    process.mix.digitizers.pixel.ThresholdInElectrons_BPix = cms.double(2000.0)
    process.mix.digitizers.pixel.ThresholdInElectrons_BPix_L1 = cms.double(2000.0)
    process.mix.digitizers.pixel.thePixelColEfficiency_BPix4 = cms.double(0.999)
    process.mix.digitizers.pixel.thePixelEfficiency_BPix4 = cms.double(0.999)
    process.mix.digitizers.pixel.thePixelChipEfficiency_BPix4 = cms.double(0.999)
    process.mix.digitizers.pixel.thePixelColEfficiency_FPix3 = cms.double(0.999)
    process.mix.digitizers.pixel.thePixelEfficiency_FPix3 = cms.double(0.999)
    process.mix.digitizers.pixel.thePixelChipEfficiency_FPix3 = cms.double(0.999)
    process.mix.digitizers.pixel.AddPixelInefficiencyFromPython = cms.bool(False)
    process.mix.digitizers.strip.ROUList = cms.vstring("g4SimHitsTrackerHitsPixelBarrelLowTof",
                         'g4SimHitsTrackerHitsPixelEndcapLowTof')
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIBLowTof"))
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIBHighTof"))
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTOBLowTof"))
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTOBHighTof"))
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTECLowTof"))
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTECHighTof"))
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIDLowTof"))
    process.mix.digitizers.mergedtruth.simHitCollections.tracker.remove( cms.InputTag("g4SimHits","TrackerHitsTIDHighTof"))

    return process
Пример #13
0
def electronTriggerMatchPT(process,triggerProcess):

   process.triggeredPatElectronsL = cms.EDProducer("ElectronTriggerMatcher",
                                            src = cms.InputTag("cleanPatElectrons"),
                                            trigEvent = cms.InputTag("hltTriggerSummaryAOD"),
                                            filters = cms.VInputTag(
                                                cms.InputTag('hltEle17CaloIdLCaloIsoVLPixelMatchFilterDoubleEG125','',triggerProcess),
                                            ),
                                            pdgId = cms.int32(0)
   )
   process.triggeredPatElectrons = cms.EDProducer("ElectronTriggerMatcher",
                                            src = cms.InputTag("triggeredPatElectronsL"),
                                            trigEvent = cms.InputTag("hltTriggerSummaryAOD"),
                                            filters = cms.VInputTag(
                                                cms.InputTag('hltOverlapFilterIsoEle15IsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle15TightIsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle18MediumIsoPFTau20','',triggerProcess),                                                
                                                cms.InputTag('hltOverlapFilterIsoEle18TightIsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle18IsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle20MediumIsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle20LooseIsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltOverlapFilterIsoEle20WP90LooseIsoPFTau20','',triggerProcess),
                                                cms.InputTag('hltEle20CaloIdVTCaloIsoTTrkIdTTrkIsoTTrackIsoFilterL1IsoEG18OrEG20','',triggerProcess),
                                                cms.InputTag('hltEle22WP90RhoTrackIsoFilter','',triggerProcess),
                                                cms.InputTag('hltEle27WP80TrackIsoFilter','',triggerProcess),
                                                cms.InputTag('hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoFilter','',triggerProcess),
                                                cms.InputTag('hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoDoubleFilter','',triggerProcess),
                                                cms.InputTag('hltEle17CaloIdVTCaloIsoVTTrkIdTTrkIsoVTEle8TrackIsoFilter','',triggerProcess),
                                                cms.InputTag('hltEle20CaloIdVTCaloIsoVTTrkIdTTrkIsoVTSC4TrackIsoFilter','',triggerProcess)
                                            ),
                                            pdgId = cms.int32(11)
   )
   
   process.analysisSequence=cms.Sequence(process.analysisSequence*process.triggeredPatElectronsL*process.triggeredPatElectrons)
Пример #14
0
def makeCategoryParams(llWPs=[], diLeptonTriggerMatch=False, addPassAll=False):
    categs = dict() ## take dilepton working points from input
    for l1 in ("El", "Mu"):
        for l2 in ("El", "Mu"):
            flav = "".join((l1,l2))
            base = cms.PSet(
                      NElectrons = cms.uint32(sum( 1 for l in (l1,l2) if l == "El" ))
                    , NMuons     = cms.uint32(sum( 1 for l in (l1,l2) if l == "Mu" ))
                    , Category   = cms.string("is{0}".format(flav))
                    , HLT        = cms.vstring(dileptonTriggers[flav]) if diLeptonTriggerMatch else cms.vstring()
                    , Cuts       = cms.VPSet(
                                        cms.PSet(Mll   = cms.string("p4.M > 20"))
                                      , cms.PSet(ZVeto = cms.string("( p4.M < 76 ) || ( p4.M > 116 )"))
                                      )
                    , WPs=cms.vstring(llWPs)
                    )
            categs["{0}OS".format(flav)]    = base.clone(Charge=cms.int32( 0), Category=cms.string("is{0} && isOS".format(flav)))
            categs["{0}Plus".format(flav)]  = base.clone(Charge=cms.int32( 1))
            categs["{0}Minus".format(flav)] = base.clone(Charge=cms.int32(-1))
    if addPassAll:
        categs["all"] = cms.PSet(
                  NElectrons = cms.uint32(0)
                , NMuons     = cms.uint32(0)
                , Category   = cms.string("")
                , HLT        = cms.vstring()
                , Cuts       = cms.VPSet()
                , WPs        = cms.vstring()
                , Charge     = cms.int32(0)
                )

    return cms.PSet(**categs)
    def addMuMuSVFit(self, moduleName):
        dicand = cms.EDProducer("PATMuMuSVFitter")
        dicand.src = cms.InputTag(self.input)
        dicand.srcPrimaryVertex = cms.InputTag("offlinePrimaryVerticesWithBS")
        dicand.srcBeamSpot = cms.InputTag("offlineBeamSpot")
        dicand.svFit = cms.PSet(
            psKine=cms.PSet(
                likelihoodFunctions=cms.VPSet(svFitLikelihoodMuMuKinematicsPhaseSpace),
                estUncertainties=cms.PSet(numSamplings=cms.int32(-1)),
            ),
            psKine_MEt=cms.PSet(
                likelihoodFunctions=cms.VPSet(svFitLikelihoodMuMuKinematicsPhaseSpace, svFitLikelihoodMuMuMEt),
                estUncertainties=cms.PSet(numSamplings=cms.int32(-1)),
            ),
            psKine_MEt_ptBalance=cms.PSet(
                likelihoodFunctions=cms.VPSet(
                    svFitLikelihoodMuMuKinematicsPhaseSpace, svFitLikelihoodMuMuMEt, svFitLikelihoodMuMuPtBalance
                ),
                estUncertainties=cms.PSet(numSamplings=cms.int32(-1)),
            ),
        )

        pyModule = sys.modules[self.pyModuleName[0]]
        if pyModule is None:
            raise ValueError("'pyModuleName' Parameter invalid")
        setattr(pyModule, moduleName, dicand)
        self.sequence *= dicand
        self.input = moduleName
Пример #16
0
def _modifyPixelDigitizerForPhase1Pixel( digitizer ) :
    """
    Function that modifies the pixel digitiser for the Phase 1 pixel detector.
    
    First argument is the pixelDigitizer object.
    """
    #use default switches, new analog respnse, d.k. 2/16
    #digitizer.MissCalibrate = False
    #digitizer.LorentzAngle_DB = False
    #digitizer.killModules = False
    #digitizer.useDB = False
    #digitizer.DeadModules_DB = False
    digitizer.NumPixelBarrel = cms.int32(4)
    digitizer.NumPixelEndcap = cms.int32(3)
    digitizer.ThresholdInElectrons_FPix = cms.double(2000.0)
    digitizer.ThresholdInElectrons_BPix = cms.double(2000.0)
    digitizer.ThresholdInElectrons_BPix_L1 = cms.double(2000.0)
    digitizer.FPix_SignalResponse_p0 = cms.double(0.00171)
    digitizer.FPix_SignalResponse_p1 = cms.double(0.711)
    digitizer.FPix_SignalResponse_p2 = cms.double(203.)
    digitizer.FPix_SignalResponse_p3 = cms.double(148.)
    digitizer.BPix_SignalResponse_p0 = cms.double(0.00171)
    digitizer.BPix_SignalResponse_p1 = cms.double(0.711)
    digitizer.BPix_SignalResponse_p2 = cms.double(203.)
    digitizer.BPix_SignalResponse_p3 = cms.double(148.)
    # gains and offsets are ints in the Clusterizer, so round to the same value
    digitizer.ElectronsPerVcal           = cms.double(47)   # L2-4: 47  +- 4.7
    digitizer.ElectronsPerVcal_L1        = cms.double(50)   # L1:   49.6 +- 2.6
    digitizer.ElectronsPerVcal_Offset    = cms.double(-60)  # L2-4: -60 +- 130
    digitizer.ElectronsPerVcal_L1_Offset = cms.double(-670) # L1:   -670 +- 220
Пример #17
0
def defineExtraHlt(process):
  process.hltHcalSimpleRecHitFilterCoincidence2 = process.hltHcalSimpleRecHitFilterCoincidence.clone(
    minNHitsNeg = cms.int32(2),
    minNHitsPos = cms.int32(2),
    doCoincidence= cms.bool(True)
    )
  process.HLT_HIActivityHF_Coincidence3_2Hit = process.HLT_HIActivityHF_Coincidence3.expandAndClone();
  process.HLT_HIActivityHF_Coincidence3_2Hit.replace(process.hltHcalSimpleRecHitFilterCoincidence,process.hltHcalSimpleRecHitFilterCoincidence2)
Пример #18
0
def disableOOTPU(process):
    process.mix.maxBunch = cms.int32(0)
    process.mix.minBunch = cms.int32(0)
    # set the bunch spacing
    # bunch spacing matters for calorimeter calibration
    # by convention bunchspace is set to 450 in case of no oot pu
    process.mix.bunchspace = 450
    return process
def customise(process):

    process.CFWriter = cms.EDProducer("CFWriter",
                                  maxBunch = cms.int32(3),
                                  minBunch = cms.int32(-5),
                                  mixObjects = cms.PSet(
                                         mixCH = cms.PSet(
                                         ),
                                         mixTracks = cms.PSet(
                                         ),
                                         mixVertices = cms.PSet(
                                         ),
                                         mixSH = cms.PSet(
                                         ),
                                         mixHepMC = cms.PSet(
                                              mixHepMCProducts
                                         )
                                   )
    )

    process.pdigi = cms.Sequence(cms.SequencePlaceholder("randomEngineStateProducer")*cms.SequencePlaceholder("mix")*process.doAllDigi*process.trackingParticles*process.addPileupInfo*process.CFWriter)

    process.RECOSIMoutput.outputCommands.append("keep *_CFWriter_*_*")


    REDIGIInputEventSkimming= cms.PSet(
        inputCommands=cms.untracked.vstring('drop *')
        )

    GeneratorInterfaceRAWNoGenParticles = process.GeneratorInterfaceRAW.outputCommands
    for item in GeneratorInterfaceRAWNoGenParticles:
      if 'genParticles' in item:
        GeneratorInterfaceRAWNoGenParticles.remove(item) 

    REDIGIInputEventSkimming.inputCommands.extend(process.SimG4CoreRAW.outputCommands) 
    REDIGIInputEventSkimming.inputCommands.extend(GeneratorInterfaceRAWNoGenParticles) 
    REDIGIInputEventSkimming.inputCommands.extend(process.IOMCRAW.outputCommands) 

    process.source.inputCommands = REDIGIInputEventSkimming.inputCommands
    process.source.dropDescendantsOfDroppedBranches=cms.untracked.bool(False)
    
    process.RandomNumberGeneratorService.restoreStateLabel = cms.untracked.string('randomEngineStateProducer')

    # Remove the old RNGState product on output
    RNGStateCleaning= cms.PSet(
        outputCommands=cms.untracked.vstring('drop RandomEngineStates_*_*_*',
                                             'keep RandomEngineStates_*_*_'+process.name_())
        )

    for item in process.outputModules_().values():
        item.outputCommands.extend(RNGStateCleaning.outputCommands)

    # REDO the GenJets etc. in case labels have been changed
    process.load('Configuration/StandardSequences/Generator_cff')
    process.fixGenInfo = cms.Path(process.GeneInfo * process.genJetMET)
    process.schedule.append(process.fixGenInfo)
    
    return(process)
Пример #20
0
def psetGsfEleEcalDrivenCut(wpEB, wpEE):
    return cms.PSet(
        cutName = cms.string('GsfEleEcalDrivenCut'),
        ecalDrivenEB = cms.int32( wpEB.ecalDrivenCut ),
        ecalDrivenEE = cms.int32( wpEE.ecalDrivenCut ),
        barrelCutOff = cms.double(ebCutOff),
        needsAdditionalProducts = cms.bool(False),
        isIgnored = cms.bool(False)
        ) 
def prepareGenMixing(process):
    
    # prepare digitizers and mixObjects for Gen-mixing
    process = prepareDigiRecoMixing(process)

    # for reasons of simplicity track mixing is not switched off,
    # although it has no effect in case of Gen-mixing

    # OOT PU not supported for Gen-mixing: disable it
    process.mix.maxBunch = cms.int32(0)
    process.mix.minBunch = cms.int32(0)
    
    # set the bunch spacing
    # bunch spacing matters for calorimeter calibration
    # setting the bunch spacing here, will have actually no effect,
    # but leads to consistency with the bunch spacing as hard coded in
    # FastSimulation/PileUpProducer/plugins/PileUpProducer.cc
    # where it is propagated to the pileUpInfo, from which calorimeter calibration reads the bunch spacing
    process.mix.bunchspace = 450

    # define the PileUpProducer module
    process.famosPileUp = cms.EDProducer(
        "PileUpProducer",
        PileUpSimulator = cms.PSet(),
        VertexGenerator = cms.PSet()
        )

    # get the pu vertex distribution
    process.famosPileUp.VertexGenerator = get_VertexGeneratorPSet_PileUpProducer(process)


    # get pu distribution from MixingModule
    process.famosPileUp.PileUpSimulator = get_PileUpSimulatorPSet_PileUpProducer(process.mix.input)     

    # MixingModule only used for digitization, no need for input
    del process.mix.input

    # Insert the PileUpProducer in the simulation sequence
    pos = process.simulationSequence.index(process.famosSimHits)
    process.simulationSequence.insert(pos,process.famosPileUp)

    # No track mixing when Gen-mixing
    del process.mix.digitizers.tracker
    del process.mix.mixObjects.mixRecoTracks
    del process.generalTracks
    process.generalTracks = process.generalTracksBeforeMixing.clone()
    process.iterTracking.replace(process.generalTracksBeforeMixing,process.generalTracks)
    del process.generalTracksBeforeMixing

    # Use generalTracks where DIGI-RECO mixing requires preMixTracks
    process.generalConversionTrackProducer.TrackProducer = cms.string('generalTracks')
    process.trackerDrivenElectronSeeds.TkColList = cms.VInputTag(cms.InputTag("generalTracks"))

    # PileUp info must be read from PileUpProducer, rather than from MixingModule
    process.addPileupInfo.PileupMixingLabel = cms.InputTag("famosPileUp")
    
    return process
def customiseFor8679(process):
    if hasattr(process,'hltBSoftMuonMu5L3') :
       delattr(process.hltBSoftMuonMu5L3,'min3DHit')
       setattr(process.hltBSoftMuonMu5L3,'minLayer', cms.int32(0))
       setattr(process.hltBSoftMuonMu5L3,'min3DLayer', cms.int32(0))
       setattr(process.hltBSoftMuonMu5L3,'minPixelHit', cms.int32(0))
       setattr(process.hltBSoftMuonMu5L3,'usePV', cms.bool(False))
       setattr(process.hltBSoftMuonMu5L3,'vertexTag', cms.InputTag(''))
    return process
Пример #23
0
def customiseFor24329(process):
    for producer in producers_by_type(process, "SiPixelClusterProducer"):
        producer.ElectronPerADCGain = cms.double(135.)
        producer.Phase2Calibration = cms.bool(False)
        producer.Phase2ReadoutMode = cms.int32(-1)
        producer.Phase2DigiBaseline = cms.double(1200.)
        producer.Phase2KinkADC = cms.int32(8)

    return process
Пример #24
0
def customiseFor8679(process):
    if hasattr(process, "hltBSoftMuonMu5L3"):
        delattr(process.hltBSoftMuonMu5L3, "min3DHit")
        setattr(process.hltBSoftMuonMu5L3, "minLayer", cms.int32(0))
        setattr(process.hltBSoftMuonMu5L3, "min3DLayer", cms.int32(0))
        setattr(process.hltBSoftMuonMu5L3, "minPixelHit", cms.int32(0))
        setattr(process.hltBSoftMuonMu5L3, "usePV", cms.bool(False))
        setattr(process.hltBSoftMuonMu5L3, "vertexTag", cms.InputTag(""))
    return process
def customise_HcalPhase1(process):
    #common stuff
    process.load("CalibCalorimetry/HcalPlugins/Hcal_Conditions_forGlobalTag_cff")
    process.es_hardcode.toGet = cms.untracked.vstring(
                'GainWidths',
                'MCParams',
                'RecoParams',
                'RespCorrs',
                'QIEData',
                'Gains',
                'Pedestals',
                'PedestalWidths',
                'ChannelQuality',
                'ZSThresholds',
                'TimeCorrs',
                'LUTCorrs',
                'LutMetadata',
                'L1TriggerObjects',
                'PFCorrs',
                'ElectronicsMap',
                'CholeskyMatrices',
                'CovarianceMatrices'
                )
    
    process.es_hardcode.hcalTopologyConstants.mode=cms.string('HcalTopologyMode::SLHC')
    process.es_hardcode.hcalTopologyConstants.maxDepthHB=cms.int32(3)
    process.es_hardcode.hcalTopologyConstants.maxDepthHB=cms.int32(3)
    process.es_hardcode.hcalTopologyConstants.maxDepthHE=cms.int32(5)
    process.es_hardcode.HcalReLabel.RelabelHits=cms.untracked.bool(True)
    # Special Upgrade trick (if absent - regular case assumed)
    process.es_hardcode.GainWidthsForTrigPrims = cms.bool(True)
    process.es_hardcode.HEreCalibCutoff = cms.double(100.) #for aging
    
    process.hcalTopologyIdeal.hcalTopologyConstants.mode=cms.string('HcalTopologyMode::SLHC')
    process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHB=cms.int32(3)
    process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHE=cms.int32(5)
    

    if hasattr(process,'g4SimHits'):
        process=customise_Sim(process)
    if hasattr(process,'DigiToRaw'):
        process=customise_DigiToRaw(process)
    if hasattr(process,'RawToDigi'):
        process=customise_RawToDigi(process)
    if hasattr(process,'digitisation_step'):
        process=customise_Digi(process)
    if hasattr(process,'reconstruction_step'):
        process=customise_Reco(process)
    if hasattr(process,'dqmoffline_step'):
        process=customise_DQM(process)
    if hasattr(process,'dqmHarvesting'):
        process=customise_harvesting(process)
    if hasattr(process,'validation_step'):
        process=customise_Validation(process)
    process=customise_condOverRides(process)
    return process
Пример #26
0
def _modifyHcalSimParametersForPostLS1( object ) :
    """
    Customises the HCal digitiser for post LS1 running
    """
    object.ho.photoelectronsToAnalog = cms.vdouble([4.0]*16)
    object.ho.siPMCode = cms.int32(1)
    object.ho.pixels = cms.int32(2500)
    object.ho.doSiPMSmearing = cms.bool(False)
    object.hf1.samplingFactor = cms.double(0.60)
    object.hf2.samplingFactor = cms.double(0.60)
def customise_Digi(process):
    if hasattr(process,'mix'):
        process.mix.digitizers.hcal.HBHEUpgradeQIE = True
        process.mix.digitizers.hcal.hb.siPMCells = cms.vint32([1])
        process.mix.digitizers.hcal.hb.photoelectronsToAnalog = cms.vdouble([10.]*16)
        process.mix.digitizers.hcal.hb.pixels = cms.int32(4500*4*2)
        process.mix.digitizers.hcal.he.photoelectronsToAnalog = cms.vdouble([10.]*16)
        process.mix.digitizers.hcal.he.pixels = cms.int32(4500*4*2)
        process.mix.digitizers.hcal.HFUpgradeQIE = True
        process.mix.digitizers.hcal.HcalReLabel.RelabelHits=cms.untracked.bool(True)

    if hasattr(process,'HcalTPGCoderULUT'):
        process.HcalTPGCoderULUT.hcalTopologyConstants.mode=cms.string('HcalTopologyMode::SLHC')
        process.HcalTPGCoderULUT.hcalTopologyConstants.maxDepthHB=cms.int32(3)
        process.HcalTPGCoderULUT.hcalTopologyConstants.maxDepthHE=cms.int32(5)

    if hasattr(process,'simHcalDigis'):
        process.simHcalDigis.useConfigZSvalues=cms.int32(1)
        process.simHcalDigis.HBlevel=cms.int32(16)
        process.simHcalDigis.HElevel=cms.int32(16)
        process.simHcalDigis.HOlevel=cms.int32(16)
        process.simHcalDigis.HFlevel=cms.int32(16)

    process.digitisation_step.remove(process.simHcalTriggerPrimitiveDigis)
    process.digitisation_step.remove(process.simHcalTTPDigis)
    
    return process
Пример #28
0
def customise(process):

  process.simHcalUnsuppressedDigis.doThermalNoise = cms.bool(False)
  #process.simSiStripDigis.CommonModeNoise = cms.bool(False)
  #process.simSiStripDigis.SingleStripNoise = cms.bool(False)
  #process.simSiStripDigis.Noise = cms.bool(False)
  #process.simSiPixelDigis.AddNoise = cms.bool(False)
  #process.simMuonRPCDigis.Noise = cms.bool(False)
  #process.simMuonCSCDigis.strips.doCorrelatedNoise = cms.bool(False)
  #process.simMuonCSCDigis.wires.doNoise = cms.bool(False)
  #process.simMuonCSCDigis.strips.doNoise = cms.bool(False)
  process.simEcalUnsuppressedDigis.    doESNoise = cms.bool(False)
  process.simCastorDigis.    doNoise = cms.bool(False)
  process.simEcalUnsuppressedDigis.    doNoise = cms.bool(False)
  process.simHcalUnsuppressedDigis.    doNoise = cms.bool(False)

  process.TFileService = cms.Service("TFileService",
      fileName = cms.string("histo.root"),
      closeFileFast = cms.untracked.bool(True)
  )

  from TrackingTools.TrackAssociator.default_cfi import TrackAssociatorParameterBlock

  myBlock=TrackAssociatorParameterBlock.clone()
  myBlock.TrackAssociatorParameters.usePreshower = cms.bool(True)

  process.ana =  cms.EDProducer('MuonCaloCleaner',
     myBlock,
     selectedMuons = cms.InputTag("muons"),
     storeDeps = cms.untracked.bool(True)
  )


  process.anaPlus = cms.EDAnalyzer("AnaMuonCaloCleaner",
    colLen = cms.InputTag("ana", "plus"),
    colDep = cms.InputTag("ana", "plusDeposits"),
    selectedMuons = cms.InputTag("muons"),
    charge = cms.int32(1)
  )

  process.anaMinus = cms.EDAnalyzer("AnaMuonCaloCleaner",
    colLen = cms.InputTag("ana", "minus"),
    colDep = cms.InputTag("ana", "minusDeposits"),
    selectedMuons = cms.InputTag("muons"),
    charge = cms.int32(-1)
  )  

  process.mySeq = cms.Sequence(process.ProductionFilterSequence*process.ana*process.anaPlus*process.anaMinus)
  process.myPath = cms.Path(process.mySeq)

  process.schedule.extend([process.myPath])

  process.MessageLogger.cerr.FwkReport.reportEvery = 100

  return process
Пример #29
0
def customiseDataRun2Common_50nsRunsAfter253000(process):
    process = customiseDataRun2Common_withStage1(process)

    if hasattr(process,'particleFlowClusterECAL'):
        process.particleFlowClusterECAL.energyCorrector.autoDetectBunchSpacing = False
        process.particleFlowClusterECAL.energyCorrector.bunchSpacing = cms.int32(50)
    if hasattr(process,'ecalMultiFitUncalibRecHit'):
        process.ecalMultiFitUncalibRecHit.algoPSet.useLumiInfoRunHeader = False
        process.ecalMultiFitUncalibRecHit.algoPSet.bunchSpacing = cms.int32(50)

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

    process.hcalTopologyIdeal.hcalTopologyConstants.mode = cms.string("HcalTopologyMode::SLHC")
    process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHB = cms.int32(7)
    process.hcalTopologyIdeal.hcalTopologyConstants.maxDepthHE = cms.int32(7)

    process.hcalTopologyIdeal.hcalTopologyConstants = cms.PSet(hcalTopologyConstants_cfi.hcalTopologyConstants)
    process.es_hardcode.hcalTopologyConstants = cms.PSet(hcalTopologyConstants_cfi.hcalTopologyConstants)
    process.CaloTowerHardcodeGeometryEP = cms.PSet(hcalTopologyConstants_cfi.hcalTopologyConstants)

    return process
conversionTrackProducers = cms.Sequence(
    generalConversionTrackProducer * conversionStepConversionTrackProducer *
    inOutConversionTrackProducer * outInConversionTrackProducer *
    gsfConversionTrackProducer)

#merge generalTracks and conversionStepTracks collections, with arbitration by nhits then chi^2/ndof for ecalseededarbitrated, mergedarbitratedecalgeneral and mergedarbitrated flags
generalConversionStepConversionTrackMerger = RecoEgamma.EgammaPhotonProducers.conversionTrackMerger_cfi.conversionTrackMerger.clone(
    TrackProducer1=cms.string('generalConversionTrackProducer'),
    TrackProducer2=cms.string('conversionStepConversionTrackProducer'),
    #prefer collection settings:
    #-1: propagate output/flag from both input collections
    # 0: propagate output/flag from neither input collection
    # 1: arbitrate output/flag (remove duplicates by shared hits), give precedence to first input collection
    # 2: arbitrate output/flag (remove duplicates by shared hits), give precedence to second input collection
    # 3: arbitrate output/flag (remove duplicates by shared hits), arbitration first by number of hits, second by chisq/ndof
    arbitratedMergedPreferCollection=cms.int32(3),
    arbitratedMergedEcalGeneralPreferCollection=cms.int32(3),
)

#merge two ecal-seeded collections, with arbitration by nhits then chi^2/ndof for ecalseededarbitrated, mergedarbitratedecalgeneral and mergedarbitrated flags
inOutOutInConversionTrackMerger = RecoEgamma.EgammaPhotonProducers.conversionTrackMerger_cfi.conversionTrackMerger.clone(
    TrackProducer1=cms.string('inOutConversionTrackProducer'),
    TrackProducer2=cms.string('outInConversionTrackProducer'),
    #prefer collection settings:
    #-1: propagate output/flag from both input collections
    # 0: propagate output/flag from neither input collection
    # 1: arbitrate output/flag (remove duplicates by shared hits), give precedence to first input collection
    # 2: arbitrate output/flag (remove duplicates by shared hits), give precedence to second input collection
    # 3: arbitrate output/flag (remove duplicates by shared hits), arbitration first by number of hits, second by chisq/ndof
    arbitratedEcalSeededPreferCollection=cms.int32(3),
    arbitratedMergedPreferCollection=cms.int32(3),
        ParameterValue = cms.vstring("TI","TO","TP","TM"),
    ),
    cms.PSet(
        ParameterName = cms.string("defaultPhases"),
        ParameterType = cms.string("vint32"),
        ParameterValue = cms.vint32(63,63,63,63),
    ),
    cms.PSet(
        ParameterName = cms.string("useEC0"),
        ParameterType = cms.string("bool"),
        ParameterValue = cms.bool(False),
    ),
    cms.PSet(
        ParameterName = cms.string("badRun"),
        ParameterType = cms.string("bool"),
        ParameterValue = cms.bool(False),
    ),
    cms.PSet(
        ParameterName = cms.string("magicOffset"),
        ParameterType = cms.string("int"),
        ParameterValue = cms.int32(8),
    ),
)

siStripConfObjectAPVPhaseOffsetsFakeESSource = cms.ESSource("SiStripConfObjectFakeESSource",
                                                            appendToDataLabel = cms.string('apvphaseoffsets')
                                                            )



Пример #33
0
      ),
      ecal = cms.PSet(
        ecalDigitizer
      ),
      hcal = cms.PSet(
        hcalDigitizer
      ),
      castor  = cms.PSet(
        castorDigitizer
      ),
      mergedtruth = cms.PSet(
        trackingParticles
      )
    ),
    LabelPlayback = cms.string(''),
    maxBunch = cms.int32(2),
    minBunch = cms.int32(-3), ## in 50ns spacing, go 150ns into past

    bunchspace = cms.int32(50), ##ns
    mixProdStep1 = cms.bool(False),
    mixProdStep2 = cms.bool(False),

    playback = cms.untracked.bool(False),
    useCurrentProcessOnly = cms.bool(False),

    input = cms.SecSource("PoolSource",
        nbPileupEvents = cms.PSet(
            averageNumber = cms.double(10.0)
        ),
        type = cms.string('poisson'),
	sequential = cms.untracked.bool(False),
Пример #34
0
#process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_condDBv2_cff')
from Configuration.AlCa.GlobalTag import GlobalTag
if runOnMC:
   process.GlobalTag.globaltag = '102X_upgrade2018_realistic_v20'#'MCRUN2_74_V9::All'
elif not(runOnMC):
   process.GlobalTag.globaltag = '102X_dataRun2_Prompt_v15'

hltFiltersProcessName = 'RECO'
if runOnMC:
   hltFiltersProcessName = 'PAT' #'RECO'

#if DOHLTFILTERS and not(runOnMC):
process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi')
process.HBHENoiseFilterResultProducer.minZeros = cms.int32(99999)
process.HBHENoiseFilterResultProducer.IgnoreTS4TS5ifJetInLowBVRegion=cms.bool(False)
process.HBHENoiseFilterResultProducer.defaultDecision = cms.string("HBHENoiseFilterResultRun2Loose")

process.ApplyBaselineHBHENoiseFilter = cms.EDFilter('BooleanFlagFilter',
                                                    inputLabel = cms.InputTag('HBHENoiseFilterResultProducer','HBHENoiseFilterResult'),
                                                    reverseDecision = cms.bool(False)
                                                    )
process.ApplyBaselineHBHEIsoNoiseFilter = cms.EDFilter('BooleanFlagFilter',
                                                       inputLabel = cms.InputTag('HBHENoiseFilterResultProducer','HBHEIsoNoiseFilterResult'),
                                                       reverseDecision = cms.bool(False)
                                                       )
process.load('RecoMET.METFilters.ecalBadCalibFilter_cfi')

from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer
baddetEcallist = cms.vuint32(
   HcalTDCFED = cms.untracked.int32(8),
   HcalQADCFED = cms.untracked.int32(8),
   HcalSlowDataFED = cms.untracked.int32(3),
   HcalTriggerFED = cms.untracked.int32(1),
   HcalVLSBFED = cms.untracked.int32(699),
   ConfigurationFile = cms.untracked.string('configQADCTDC_TB2009.txt')
)

process.hcalDigis = cms.EDFilter("HcalRawToDigi",
    UnpackZDC = cms.untracked.bool(True),
    FilterDataQuality = cms.bool(True),
    ExceptionEmptyData = cms.untracked.bool(True),
    InputLabel = cms.InputTag("source"),
    ComplainEmptyData = cms.untracked.bool(False),
    UnpackCalib = cms.untracked.bool(False),
    firstSample = cms.int32(0),
    lastSample = cms.int32(9),
    FEDs = cms.untracked.vint32(21),
    HcalFirstFED = cms.untracked.int32(21)
)
process.load("RecoLocalCalo.HcalRecProducers.HcalSimpleReconstructor_hbhe_cfi")
process.hbhereco.firstSample = 5
process.hbhereco.samplesToAdd = 4

process.options = cms.untracked.PSet(
    Rethrow = cms.untracked.vstring('ProductNotFound', 
        'TooManyProducts', 
        'TooFewProducts')
)

process.triggerfilter = cms.EDFilter("TriggerFilter",
from Configuration.Generator.PyquenTuneZ2Settings_cff import *

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

hiSignal.doQuench = cms.bool(False)
hiSignal.doIsospin = cms.bool(False)
hiSignal.protonSide = cms.untracked.int32(0)
hiSignal.embeddingMode = True

configurationMetadata = cms.untracked.PSet(
    version = cms.untracked.string('$Revision: 1.5 $'),
    name = cms.untracked.string('$Source: /cvs_server/repositories/CMSSW/CMSSW/Configuration/GenProduction/python/HI/Pyquen_Dijet30_pp_Unquenched_TuneZ2_5p02TeV_cff.py,v $'),
    annotation = cms.untracked.string('PYQUEN UNquenched dijets (pt-hat > 30 GeV) at sqrt(s) = 5.02TeV')
    )
import FWCore.ParameterSet.Config as cms
from GeneratorInterface.ReggeGribovPartonMCInterface.ReggeGribovPartonMC_AdvancedParameters_cfi import *

generator = cms.EDFilter(
    "ReggeGribovPartonMCGeneratorFilter",
    ReggeGribovPartonMCAdvancedParameters,
    beammomentum=cms.double(2510),
    targetmomentum=cms.double(-2510),
    beamid=cms.int32(1),
    targetid=cms.int32(208),
    model=cms.int32(0),
)

configurationMetadata = cms.untracked.PSet(
    version=cms.untracked.string('$Revision: 1.4 $'),
    name=cms.untracked.string(
        '$Source: /local/reps/CMSSW/CMSSW/GeneratorInterface/ReggeGribovPartonMCInterface/python/ReggeGribovPartonMC_EposLHC_5TeV_pPb_cfi.py,v $'
    ),
    annotation=cms.untracked.string('ReggeGribovMC generator'))

particlefilter = cms.EDFilter(
    "PythiaFilter",
    Status=cms.untracked.int32(1),
    MaxRapidity=cms.untracked.double(2.4),
    MinRapidity=cms.untracked.double(-2.4),
    MinPt=cms.untracked.double(5.9),
    MaxPt=cms.untracked.double(999.),
    ParticleID=cms.untracked.int32(3312),
)

ProductionFilterSequence = cms.Sequence(generator + particlefilter)
#---------------
# Input sources
if unitTest:
    process.load("DQM.Integration.config.unittestinputsource_cfi")
    from DQM.Integration.config.unittestinputsource_cfi import options
elif live:
    process.load("DQM.Integration.config.inputsource_cfi")
    from DQM.Integration.config.inputsource_cfi import options
else:
    process.load("DQM.Integration.config.fileinputsource_cfi")
    from DQM.Integration.config.fileinputsource_cfi import options

#--------------------------
# HLT Filter
process.hltTriggerTypeFilter = cms.EDFilter("HLTTriggerTypeFilter",
    SelectedTriggerType = cms.int32(1) # physics
)

#----------------------------
# DQM Live Environment
process.load("DQM.Integration.config.environment_cfi")
process.dqmEnv.subSystemFolder = 'BeamMonitor'
process.dqmSaver.tag           = 'BeamMonitor'
process.dqmSaver.runNumber     = options.runNumber
process.dqmSaverPB.tag         = 'BeamMonitor'
process.dqmSaverPB.runNumber   = options.runNumber

process.dqmEnvPixelLess = process.dqmEnv.clone()
process.dqmEnvPixelLess.subSystemFolder = 'BeamMonitor_PixelLess'

#---------------
Пример #39
0
    MaxEta=cms.double(0.5655),
    MinPhi=cms.double(0.1309),
    MaxPhi=cms.double(0.1309),
    BeamPosition=cms.double(-408.50))

from IOMC.EventVertexGenerators.VtxSmearedParameters_cfi import *
process.VtxSmeared = cms.EDProducer("BeamProfileVtxGenerator",
                                    process.common_beam_direction_parameters,
                                    VtxSmearedCommon,
                                    BeamMeanX=cms.double(0.0),
                                    BeamMeanY=cms.double(0.0),
                                    BeamSigmaX=cms.double(0.0001),
                                    BeamSigmaY=cms.double(0.0001),
                                    Psi=cms.double(999.9),
                                    GaussianProfile=cms.bool(False),
                                    BinX=cms.int32(50),
                                    BinY=cms.int32(50),
                                    File=cms.string('beam.profile'),
                                    UseFile=cms.bool(False),
                                    TimeOffset=cms.double(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,
                            MinE=cms.double(9.99),
                            MaxE=cms.double(10.01),
                            PartID=cms.vint32(211)),
 recHits4DLabel = cms.InputTag('dt4DSegments'), 
 rootFileName = cms.untracked.string('DTTMaxHistos.root'),
 debug = cms.untracked.bool(False),
 # Choose the chamber you want to calibrate (default = "All"), specify the chosen chamber
 # in the format "wheel station sector" (i.e. "-1 3 10")
 calibChamber = cms.untracked.string('All'),
 # Chosen granularity (N.B. bySL is the only one implemented at the moment)  
 tMaxGranularity = cms.untracked.string('bySL'),
 # The module to be used for ttrig synchronization and its set parameter
 tTrigMode = cms.string('DTTTrigSyncFromDB'),
 tTrigModeConfig = cms.PSet(
     # The velocity of signal propagation along the wire (cm/ns)
     vPropWire = cms.double(24.4),
     # Switch on/off the TOF correction for particles
     doTOFCorrection = cms.bool(False),
     tofCorrType = cms.int32(0),
     wirePropCorrType = cms.int32(0),
     # Switch on/off the correction for the signal propagation along the wire
     doWirePropCorrection = cms.bool(False),
     # Switch on/off the TO correction from pulses
     doT0Correction = cms.bool(True),
     debug = cms.untracked.bool(False),
     tTrigLabel = cms.string('cosmics')
 ),
 # Choose to calculate vDrift and t0 or just fill the TMax histograms
 findVDriftAndT0 = cms.untracked.bool(False),
 # Parameter set for DTCalibrationMap constructor
 calibFileConfig = cms.untracked.PSet(
     nFields = cms.untracked.int32(6),
     calibConstGranularity = cms.untracked.string('bySL'),
     calibConstFileName = cms.untracked.string('vDriftAndReso.txt')
Пример #41
0
import FWCore.ParameterSet.Config as cms

from RecoMET.METFilters.CSCTightHaloFilter_cfi import *
CSCTightHaloFilter.taggingMode = cms.bool(True)

from RecoMET.METFilters.eeBadScFilter_cfi import *
eeBadScFilter.taggingMode = cms.bool(True)

primaryVertexFilter = cms.EDFilter(
    "GoodVertexFilter",
    vertexCollection=cms.InputTag('offlinePrimaryVertices'),
    minimumNDOF=cms.uint32(4),
    maxAbsZ=cms.double(15),
    maxd0=cms.double(2),
    filter=cms.bool(False))

from CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi import *
HBHENoiseFilterResultProducer.minZeros = cms.int32(99999)

from RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi import *
EcalDeadCellTriggerPrimitiveFilter.taggingMode = cms.bool(True)

ggMETFiltersSequence = cms.Sequence(
    CSCTightHaloFilter * HBHENoiseFilterResultProducer * primaryVertexFilter *
    eeBadScFilter * EcalDeadCellTriggerPrimitiveFilter)
Пример #42
0
import FWCore.ParameterSet.Config as cms

PFJetParameters = cms.PSet(
    src=cms.InputTag('particleFlow'),
    srcPVs=cms.InputTag(''),
    jetType=cms.string('PFJet'),
    jetPtMin=cms.double(5.0),
    inputEMin=cms.double(0.0),
    inputEtMin=cms.double(0.0),
    doPVCorrection=cms.bool(False),
    # pileup with offset correction
    doPUOffsetCorr=cms.bool(False),
    # if pileup is false, these are not read:
    #nSigmaPU = cms.double(1.0),
    #radiusPU = cms.double(0.5),
    # fastjet-style pileup
    doAreaFastjet=cms.bool(True),
    doRhoFastjet=cms.bool(False),
    doAreaDiskApprox=cms.bool(False),
    Active_Area_Repeats=cms.int32(1),
    GhostArea=cms.double(0.01),
    Ghost_EtaMax=cms.double(5.0),
    Rho_EtaMax=cms.double(4.4),
    voronoiRfact=cms.double(-0.9),
    useDeterministicSeed=cms.bool(True),
    minSeed=cms.uint32(14327),
    applyWeight=cms.bool(False))
Пример #43
0
import FWCore.ParameterSet.Config as cms

from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
dtTriggerSynchMonitor = DQMEDAnalyzer('DTLocalTriggerSynchTask',
    staticBooking = cms.untracked.bool(True),
    # labels of DDU/TM data and 4D segments
    TMInputTag    = cms.InputTag('dttfDigis'),
    DDUInputTag    = cms.InputTag('muonDTDigis'),
    SEGInputTag    = cms.InputTag('dt4DSegments'),
    processDDU     = cms.untracked.bool(True),
    bxTimeInterval = cms.double(25),
    rangeWithinBX  = cms.bool(True),
    nBXHigh        = cms.int32(0),
    nBXLow         = cms.int32(1),
    angleRange     = cms.double(30.),
    minHitsPhi     = cms.int32(7),
    baseDir        = cms.string("DT/90-LocalTriggerSynch/"),
    tTrigModeConfig = cms.PSet(
            vPropWire = cms.double(24.4),
            doTOFCorrection = cms.bool(False),
            tofCorrType = cms.int32(0),
            wirePropCorrType = cms.int32(0),
            doWirePropCorrection = cms.bool(False),
            doT0Correction = cms.bool(False),
            debug = cms.untracked.bool(False),
            tTrigLabel = cms.string('')
    ),
    tTrigMode = cms.string('DTTTrigSyncFromDB')
)

from Configuration.Eras.Modifier_run2_DT_2018_cff import run2_DT_2018
if unitTest == True:
    process.load("DQM.Integration.config.unittestinputsource_cfi")
    from DQM.Integration.config.unittestinputsource_cfi import options
else:
    process.load("DQM.Integration.config.inputsource_cfi")
    from DQM.Integration.config.inputsource_cfi import options
# Use this to run locally (for testing purposes)
#process.load("DQM.Integration.config.fileinputsource_cfi")
#from DQM.Integration.config.fileinputsource_cfi import options


#----------------------------
# HLT Filter
#----------------------------
# 0=random, 1=physics, 2=calibration, 3=technical
process.hltTriggerTypeFilter = cms.EDFilter("HLTTriggerTypeFilter", SelectedTriggerType = cms.int32(1))


#----------------------------
# DQM Environment
#----------------------------
process.load("DQM.Integration.config.environment_cfi")
process.dqmEnv.subSystemFolder = "BeamPixel"
process.dqmSaver.tag = "BeamPixel"
process.dqmSaver.runNumber = options.runNumber
process.dqmSaverPB.tag = 'BeamPixel'
process.dqmSaverPB.runNumber = options.runNumber

#----------------------------
# Conditions
#----------------------------
import FWCore.ParameterSet.Config as cms

phase2trackClusterRemover = cms.EDProducer(
    'TrackClusterRemoverPhase2',
    trajectories=cms.InputTag(''),
    trackClassifier=cms.InputTag('', 'QualityMasks'),
    phase2pixelClusters=cms.InputTag('siPixelClusters'),
    phase2OTClusters=cms.InputTag('siPhase2Clusters'),
    oldClusterRemovalInfo=cms.InputTag(''),
    TrackQuality=cms.string('highPurity'),
    maxChi2=cms.double(30),
    minNumberOfLayersWithMeasBeforeFiltering=cms.int32(0),
    overrideTrkQuals=cms.InputTag(''))
import FWCore.ParameterSet.Config as cms

generalTpSelectorBlock = cms.PSet(lip=cms.double(30.0),
                                  chargedOnly=cms.bool(True),
                                  pdgId=cms.vint32(),
                                  signalOnly=cms.bool(True),
                                  intimeOnly=cms.bool(False),
                                  stableOnly=cms.bool(False),
                                  minRapidity=cms.double(-2.5),
                                  minHit=cms.int32(0),
                                  ptMin=cms.double(0.9),
                                  ptMax=cms.double(1e100),
                                  maxRapidity=cms.double(2.5),
                                  tip=cms.double(2.0),
                                  minPhi=cms.double(-3.2),
                                  maxPhi=cms.double(3.2),
                                  invertRapidityCut=cms.bool(False))

from Configuration.Eras.Modifier_fastSim_cff import fastSim
fastSim.toModify(generalTpSelectorBlock, stableOnly=True)

TpSelectorForEfficiencyVsEtaBlock = generalTpSelectorBlock.clone()
TpSelectorForEfficiencyVsPhiBlock = generalTpSelectorBlock.clone()
TpSelectorForEfficiencyVsPtBlock = generalTpSelectorBlock.clone(ptMin=0.050)
TpSelectorForEfficiencyVsVTXRBlock = generalTpSelectorBlock.clone(tip=60.0)
TpSelectorForEfficiencyVsVTXZBlock = generalTpSelectorBlock.clone()


def _modifyForPhase1(pset):
    pset.minRapidity = -3
    pset.maxRapidity = 3
Пример #47
0
        deltaSignificanceCut=cms.untracked.double(10)),
    PVFitter=cms.PSet(
        Debug=cms.untracked.bool(False),
        Apply3DFit=cms.untracked.bool(True),
        VertexCollection=cms.untracked.InputTag('offlinePrimaryVertices'),
        #WriteAscii = cms.untracked.bool(True),
        #AsciiFileName = cms.untracked.string('PVFit.txt'),
        maxNrStoredVertices=cms.untracked.uint32(10000),
        minNrVerticesForFit=cms.untracked.uint32(50),
        minVertexNdf=cms.untracked.double(10.),
        maxVertexNormChi2=cms.untracked.double(10.),
        minVertexNTracks=cms.untracked.uint32(0),
        minVertexMeanWeight=cms.untracked.double(0.5),
        maxVertexR=cms.untracked.double(2),
        maxVertexZ=cms.untracked.double(10),
        errorScale=cms.untracked.double(0.9),
        nSigmaCut=cms.untracked.double(5.),
        FitPerBunchCrossing=cms.untracked.bool(True)),
    dxBin=cms.int32(200),
    dxMin=cms.double(-1.0),
    dxMax=cms.double(1.0),
    vxBin=cms.int32(200),
    vxMin=cms.double(-0.5),
    vxMax=cms.double(0.5),
    dzBin=cms.int32(80),
    dzMin=cms.double(-20),
    dzMax=cms.double(20),
    phiBin=cms.int32(63),
    phiMin=cms.double(-3.15),
    phiMax=cms.double(3.15))
process.FEVTDEBUGHLToutput = cms.OutputModule(
    "PoolOutputModule",
    dataset=cms.untracked.PSet(
        dataTier=cms.untracked.string('GEN-SIM-DIGI-RAW'),
        filterName=cms.untracked.string('')),
    eventAutoFlushCompressedSize=cms.untracked.int32(10485760),
    fileName=cms.untracked.string('file:step2.root'),
    outputCommands=process.FEVTDEBUGHLTEventContent.outputCommands,
    splitLevel=cms.untracked.int32(0))

# Additional output definition

# Other statements
process.mix.input.nbPileupEvents.averageNumber = cms.double(200.000000)
process.mix.bunchspace = cms.int32(25)
process.mix.minBunch = cms.int32(-3)
process.mix.maxBunch = cms.int32(3)
process.mix.input.fileNames = cms.untracked.vstring([
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_1.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_10.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_100.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_11.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_12.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_13.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_14.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_15.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_16.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_17.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_18.root',
    '/store/group/lpcfpix/MinBias_14TeV_923_OT613_200_IT4025_opt6s3l/GenSim/170721_051411/0000/step1_19.root',
Пример #49
0
        veto=cms.double(0.699),
    ),
    ###          cms.PSet(
    ###              algo=cms.string("DiphotonsFootPrintRemovedIsolationAlgo"),
    ###              name=cms.string("fpr03"),
    ###              coneSize=cms.double(0.3), doRandomCone=cms.bool(False), removePhotonsInMap=cms.int32(1),
    ###              rechitLinkEnlargement=cms.double(0.25),
    ###              charged=cms.vdouble(0.02,0.02,0.1),
    ###              photon=cms.vdouble(0.0, 0.070, 0.015, 0.0, 0.0, 0.0),
    ###              ),
    cms.PSet(
        algo=cms.string("DiphotonsFootPrintRemovedIsolationAlgo"),
        name=cms.string("fprNoMap03"),
        coneSize=cms.double(0.3),
        doRandomCone=cms.bool(False),
        removePhotonsInMap=cms.int32(0),
        rechitLinkEnlargement=cms.double(0.25),
        photon=cms.vdouble(0.0, 0.070, 0.015, 0.0, 0.0, 0.0),
        charged=cms.vdouble(0.02, 0.02, 0.1),
    ),
    #### cms.PSet(
    ####     algo=cms.string("DiphotonsFootPrintRemovedIsolationAlgo"),
    ####     name=cms.string("fprRnd03"),
    ####     coneSize=cms.double(0.3), doRandomCone=cms.bool(True), removePhotonsInMap=cms.int32(1),
    ####     rechitLinkEnlargement=cms.double(0.25),
    ####     charged=cms.vdouble(0.02,0.02,0.1),
    ####     vetoCollections_=cms.VInputTag(cms.InputTag("vetoPhotons"),cms.InputTag("vetoJets")),
    ####     veto=cms.double(0.699),
    ####     ),
])
Пример #50
0
process.load('ISpy.Analyzers.ISpyRPCRecHit_cfi')
process.load('ISpy.Analyzers.ISpySiPixelCluster_cfi')
process.load('ISpy.Analyzers.ISpySiPixelRecHit_cfi')
process.load('ISpy.Analyzers.ISpySiStripCluster_cfi')
process.load('ISpy.Analyzers.ISpySiStripDigi_cfi')
process.load('ISpy.Analyzers.ISpySuperCluster_cfi')
process.load('ISpy.Analyzers.ISpyTrack_cfi')
process.load('ISpy.Analyzers.ISpyTrackingRecHit_cfi')
process.load('ISpy.Analyzers.ISpyTriggerEvent_cfi')
process.load('ISpy.Analyzers.ISpyVertex_cfi')

process.ISpyBasicCluster.iSpyBasicClusterTag = cms.InputTag("hybridSuperClusters:hybridBarrelBasicClusters")
process.ISpyCSCRecHit2D.iSpyCSCRecHit2DTag = cms.InputTag("csc2DRecHits")
process.ISpyCSCSegment.iSpyCSCSegmentTag = cms.InputTag("cscSegments")
process.ISpyCSCStripDigi.iSpyCSCStripDigiTag = cms.InputTag('muonCSCDigis:MuonCSCStripDigi')
process.ISpyCSCStripDigi.thresholdOffset = cms.int32(9)
process.ISpyCSCWireDigi.iSpyCSCWireDigiTag = cms.InputTag('muonCSCDigis:MuonCSCWireDigi')
process.ISpyCaloCluster.iSpyCaloClusterTag = cms.InputTag("hybridSuperClusters:hybridBarrelBasicClusters")
process.ISpyCaloTower.iSpyCaloTowerTag = cms.InputTag('towerMaker')
process.ISpyCaloMET.iSpyCaloMETTag = cms.InputTag('met')
process.ISpyCaloTau.iSpyCaloTauTag = cms.InputTag('caloRecoTauProducer')
process.ISpyDTDigi.iSpyDTDigiTag = cms.InputTag('muonDTDigis')
process.ISpyDTRecHit.iSpyDTRecHitTag = cms.InputTag('dt1DRecHits')
process.ISpyDTRecSegment4D.iSpyDTRecSegment4DTag = cms.InputTag('dt4DSegments')
process.ISpyEBRecHit.iSpyEBRecHitTag = cms.InputTag('ecalRecHit:EcalRecHitsEB')
process.ISpyEERecHit.iSpyEERecHitTag = cms.InputTag('ecalRecHit:EcalRecHitsEE')
process.ISpyESRecHit.iSpyESRecHitTag = cms.InputTag('ecalPreshowerRecHit:EcalRecHitsES')
#process.ISpyElectron.iSpyElectronTag = cms.InputTag('hltPixelMatchElectronsL1Iso')
process.ISpyGsfElectron.iSpyGsfElectronTag = cms.InputTag('gsfElectrons')
process.ISpyGsfPFRecTrack.iSpyGsfPFRecTrackTag = cms.InputTag('pfTrackElec')
process.ISpyGsfTrack.iSpyGsfTrackTag = cms.InputTag('electronGsfTracks')
Пример #51
0
ctppsDiamondDQMSource = cms.EDAnalyzer(
    "CTPPSDiamondDQMSource",
    tagStatus=cms.InputTag("ctppsDiamondRawToDigi", "TimingDiamond"),
    tagDigi=cms.InputTag("ctppsDiamondRawToDigi", "TimingDiamond"),
    tagFEDInfo=cms.InputTag("ctppsDiamondRawToDigi", "TimingDiamond"),
    tagDiamondRecHits=cms.InputTag("ctppsDiamondRecHits"),
    tagDiamondLocalTracks=cms.InputTag("ctppsDiamondLocalTracks"),
    tagLocalTrack=cms.InputTag("totemRPLocalTrackFitter"),
    excludeMultipleHits=cms.bool(True),
    minimumStripAngleForTomography=cms.double(0),
    maximumStripAngleForTomography=cms.double(1),
    offsetsOOT=cms.VPSet(  # cut on the OOT bin for physics hits
        # 2016, after TS2
        cms.PSet(
            validityRange=cms.EventRange("1:min - 292520:max"),
            centralOOT=cms.int32(1),
        ),
        # 2017
        cms.PSet(
            validityRange=cms.EventRange("292521:min - 301417:max"),
            centralOOT=cms.int32(3),
        ),
        # 2017, after channel delays corrections
        cms.PSet(
            validityRange=cms.EventRange("301418:min - 301517:max"),
            centralOOT=cms.int32(1),
        ),
        # 2017, after channel delays corrections
        cms.PSet(
            validityRange=cms.EventRange("301518:min - 9999999:max"),
            centralOOT=cms.int32(0),
Пример #52
0
process.source = cms.Source("PoolSource",
    # replace 'myfile.root' with the source file you want to use
    fileNames = cms.untracked.vstring(
'/store/hidata/HIRun2015/HIMinimumBias7/AOD/02May2016-v1/00000/089673D3-6199-E611-B9E9-1418774A30CD.root'
)
)

process.load("Flow.V2Analyzer.v2analyzerCumulant_cfi")


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

process.demo_n1 = process.demo.clone(
                      useCentrality = cms.bool(False),
                      efftableName = cms.string('eff_1'),
                      Nmin = cms.int32(90),
                      Nmax = cms.int32(120),
                      order = cms.int32(2),  
)


process.demo_n2 = process.demo.clone(
                      useCentrality = cms.bool(False),
                      efftableName = cms.string('eff_2'),
                      Nmin = cms.int32(120),
                      Nmax = cms.int32(150),
                      order = cms.int32(2),  
)

process.demo_n3 = process.demo.clone(
                      useCentrality = cms.bool(False),
Пример #53
0
import FWCore.ParameterSet.Config as cms

DA_vectParameters = cms.PSet(
    algorithm=cms.string("DA_vect"),
    TkDAClusParameters=cms.PSet(
        coolingFactor=cms.double(0.6),  # moderate annealing speed
        zrange=cms.double(
            4.),  # consider only clusters within 4 sigma*sqrt(T) of a track
        delta_highT=cms.double(1.e-2),  # convergence requirement at high T
        delta_lowT=cms.double(1.e-3),  # convergence requirement at low T
        convergence_mode=cms.int32(
            0),  # 0 = two steps, 1 = dynamic with sqrt(T)
        Tmin=cms.double(2.0),  # end of vertex splitting
        Tpurge=cms.double(2.0),  # cleaning 
        Tstop=cms.double(0.5),  # end of annealing 
        vertexSize=cms.double(
            0.006),  # added in quadrature to track-z resolutions        
        d0CutOff=cms.double(3.),  # downweight high IP tracks 
        dzCutOff=cms.double(
            3.),  # outlier rejection after freeze-out (T<Tmin)       
        zmerge=cms.double(
            1e-2),  # merge intermediat clusters separated by less than zmerge
        uniquetrkweight=cms.double(
            0.8),  # require at least two tracks with this weight at T=Tpurge
        uniquetrkminp=cms.double(
            0.0)  # minimal a priori track weight for counting unique tracks
    ))

from Configuration.Eras.Modifier_highBetaStar_2018_cff import highBetaStar_2018
highBetaStar_2018.toModify(DA_vectParameters,
                           TkDAClusParameters=dict(Tmin=4.0,
Пример #54
0
import FWCore.ParameterSet.Config as cms
import os

source = cms.Source("EmptySource")

generator = cms.EDFilter(
    "SherpaGeneratorFilter",
    maxEventsToPrint=cms.int32(0),
    filterEfficiency=cms.untracked.double(1.0),
    crossSection=cms.untracked.double(-1),
    SherpaProcess=cms.string('Znunugamma_aTGC_Zgg_h30p0_h4m0p0000006'),
    SherpackLocation=cms.string('./'),
    SherpackChecksum=cms.string('79e24b260d7fdb7e1a865b4e8637fad2'),
    FetchSherpack=cms.bool(False),
    SherpaPath=cms.string('./'),
    SherpaPathPiece=cms.string('./'),
    SherpaResultDir=cms.string('Result'),
    SherpaDefaultWeight=cms.double(1.0),
    SherpaParameters=cms.PSet(
        parameterSets=cms.vstring("MPI_Cross_Sections", "Run"),
        MPI_Cross_Sections=cms.vstring(
            " MPIs in Sherpa, Model = Amisic:", " semihard xsec = 37.4634 mb,",
            " non-diffractive xsec = 17.0318 mb with nd factor = 0.3142."),
        Run=cms.vstring(
            " (run){", " EVENTS = 1; ERROR 0.1;",
            " FSF:=1.; RSF:=1.; QSF:=1.;",
            " SCALES STRICT_METS{FSF*MU_F2}{RSF*MU_R2}{QSF*MU_Q2};",
            " ME_SIGNAL_GENERATOR Comix;",
            " EVENT_GENERATION_MODE PartiallyUnweighted;", " MASSIVE[5] 1",
            " MASSIVE[4] 1", " BEAM_1 2212; BEAM_ENERGY_1 6500.;",
            " BEAM_2 2212; BEAM_ENERGY_2 6500.;",
Пример #55
0
import FWCore.ParameterSet.Config as cms

ckfBaseTrajectoryFilterP5 = cms.PSet(
    ComponentType=cms.string('CkfBaseTrajectoryFilter'),
    chargeSignificance=cms.double(-1.0),
    constantValueForLostHitsFractionFilter=cms.double(2.0),
    extraNumberOfHitsBeforeTheFirstLoop=cms.int32(4),
    maxCCCLostHits=cms.int32(9999),
    maxConsecLostHits=cms.int32(3),
    maxLostHits=cms.int32(4),
    maxLostHitsFraction=cms.double(0.1),
    maxNumberOfHits=cms.int32(100),
    minGoodStripCharge=cms.PSet(
        refToPSet_=cms.string('SiStripClusterChargeCutNone')),
    minHitsMinPt=cms.int32(3),
    minNumberOfHitsForLoopers=cms.int32(13),
    minNumberOfHitsPerLoop=cms.int32(4),
    minPt=cms.double(0.5),
    minimumNumberOfHits=cms.int32(5),
    nSigmaMinPt=cms.double(5.0),
    pixelSeedExtension=cms.bool(False),
    seedExtension=cms.int32(0),
    seedPairPenalty=cms.int32(0),
    strictSeedExtension=cms.bool(False))
workingPoints = dict(
    wpLoose = MVA_WPLoose
)


#
# Finally, set up VID configuration for all cuts
#

# Create the PSet that will be fed to the MVA value map producer
mvaEleID_Spring16_HZZ_V1_producer_config = cms.PSet(
    mvaName            = cms.string(mvaClassName),
    mvaTag             = cms.string(mvaTag),
    # Category parameters
    nCategories         = cms.int32(6),
    categoryCuts        = cms.vstring(*EleMVA_6CategoriesCuts),
    # Weight files and variable definitions
    weightFileNames     = mvaSpring16WeightFiles_V1,
    variableDefinition  = cms.string(mvaVariablesFile)
    )
# Create the VPset's for VID cuts
mvaEleID_Spring16_HZZ_V1_wpLoose = configureVIDMVAEleID( MVA_WPLoose )


# The MD5 sum numbers below reflect the exact set of cut variables
# and values above. If anything changes, one has to 
# 1) comment out the lines below about the registry, 
# 2) run "calculateMD5 <this file name> <one of the VID config names just above>
# 3) update the MD5 sum strings below and uncomment the lines again.
#
)
process.GlobalTag.globaltag = cms.string(
    '80X_mcRun2_asymptotic_2016_TrancheIV_v6')

#-----------------------------
# ADD THE ANALYSIS MODULE
#-----------------------------
process.load('ExLep2017Tree.Selection.EventSelectors_cfi')
process.myMiniTreeProducer.MCTruth.isData = cms.bool(isData)
if isData:
    process.myMiniTreeProducer.MCTruth.sampleCode = cms.string("DATA")
else:
    #for multi CRAB
    process.myMiniTreeProducer.MCTruth.sampleCode = cms.string(
        "ExLepMuMuZ_M4500")
process.myMiniTreeProducer.minEventQualityToStore = cms.int32(1)
##https://github.com/cms-jet/JRDatabase/tree/master/textFiles/Fall17_V3_MC
process.myMiniTreeProducer.Jets.resolutionsFile = cms.string(
    'Fall17_V3_MC_PtResolution_AK8PF.txt')
process.myMiniTreeProducer.Jets.scaleFactorsFile = cms.string(
    'Fall17_V3_MC_SF_AK8PF.txt')
process.myMiniTreeProducer.Trigger.source = cms.InputTag('TriggerResults::HLT')
process.myMiniTreeProducer.Trigger.trigBits = cms.vstring(
    "HLT_IsoMu24", "HLT_IsoTkMu24", "HLT_Mu50", "HLT_TkMu50",
    "HLT_DoubleEle33", "HLT_Ele27_WPTight_Gsf")

#------------------------------------------------------
# apply partial MET filters via trigger selection.
# BadPFMuonFilter and BadChargedCandidateFilter are
# run on fly through addMETFilters (process)
#------------------------------------------------------
Пример #58
0
# Set up electron ID (VID framework)
# https://twiki.cern.ch/twiki/bin/view/CMS/MultivariateElectronIdentificationRun2
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
# define which IDs we want to produce and add them to the VID producer
for idmod in [
        'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_PHYS14_PU20bx25_nonTrig_V1_cff'
]:
    setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)

# Set up HBHE noise filter
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/MissingETOptionalFiltersRun2
print "Setting up HBHE noise filter"
process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi')
process.HBHENoiseFilterResultProducer.minZeros = cms.int32(99999)
process.HBHENoiseFilterResultProducer.IgnoreTS4TS5ifJetInLowBVRegion = cms.bool(
    False)
process.HBHENoiseFilterResultProducer.defaultDecision = cms.string(
    "HBHENoiseFilterResultRun2Loose")
# Do not apply EDfilters for HBHE noise, the discriminators for them are saved into the ttree

process.load("HiggsAnalysis/MiniAOD2TTree/PUInfo_cfi")
process.load("HiggsAnalysis/MiniAOD2TTree/TopPt_cfi")
process.load("HiggsAnalysis/MiniAOD2TTree/Tau_cfi")
process.load("HiggsAnalysis/MiniAOD2TTree/Electron_cfi")
process.load("HiggsAnalysis/MiniAOD2TTree/Muon_cfi")
process.load("HiggsAnalysis/MiniAOD2TTree/Jet_cfi")
process.load("HiggsAnalysis/MiniAOD2TTree/MET_cfi")
process.load("HiggsAnalysis/MiniAOD2TTree/METNoiseFilter_cfi")
process.METNoiseFilter.triggerResults = cms.InputTag(
Пример #59
0
import FWCore.ParameterSet.Config as cms

stdCTAnaPset = cms.PSet(
    recoVertexCollection=cms.InputTag("offlinePrimaryVertices"),
    caloTowerCollection=cms.InputTag("towerMaker"),
    vtxSel=cms.int32(20),
    cutEt=cms.bool(True),
    etTh=cms.double(1.),
    etEmTh=cms.double(-999.),
    etHadTh=cms.double(-999.))

caloTowerAnalysis = cms.EDAnalyzer("CaloTowerAnalysis", stdCTAnaPset)
Пример #60
0
 "nDump": cms.untracked.int32(0),
 "nDumpTracks": cms.untracked.int32(0),
 #  "mintrkweight":cms.untracked.double(0.5),
 "uniquetrkweight": cms.double(0.8),
 "uniquetrkminp": cms.double(0.0),
 "zmerge": cms.double(1.e-2),
 "coolingFactor": cms.double(0.6),
 "Tmin": cms.double(0),  # 0 = not set, use default
 "Tpurge": cms.double(0),
 "Tstop": cms.double(0),
 "vertexSize": cms.double(0.006),
 "vertexSizeTime": cms.double(0.008),
 "d0CutOff": cms.double(3.),
 "dzCutOff": cms.double(3.),
 "zrange": cms.double(4),
 "convergence_mode": cms.int32(0),
 "delta_lowT": cms.double(1.e-3),
 "delta_highT": cms.double(1.e-2),
 # track selection
 "maxNormalizedChi2": cms.double(10.0),
 "minPixelLayersWithHits": cms.int32(2),
 "minSiliconLayersWithHits": cms.int32(5),
 "maxD0Significance": cms.double(4.0),
 "minPt": cms.double(0.0),
 "maxEta": cms.double(2.4),
 "trackQuality": cms.string("any"),
 # track selection, experimental
 "maxDzError": cms.double(1.0),
 "maxD0Error": cms.double(1.0),
 # vertex selection
 "minNdof": cms.double(0.0),