import FWCore.ParameterSet.Config as cms

from RecoTauTag.RecoTau.PFRecoTauQualityCuts_cfi import PFTauQualityCuts
from RecoTauTag.RecoTau.TauDiscriminatorTools import requireLeadTrack
from RecoTauTag.RecoTau.PFRecoTauDiscriminationByIsolation_cfi import pfRecoTauDiscriminationByIsolation

pfRecoTauDiscriminationByTrackIsolation = pfRecoTauDiscriminationByIsolation.clone(
    PFTauProducer=cms.InputTag(
        'pfRecoTauProducer'),  #tau collection to discriminate

    # Require leading pion ensures that:
    #  1) these is at least one track above threshold (0.5 GeV) in the signal cone
    #  2) a track in the signal cone has pT > 5 GeV
    Prediscriminants=requireLeadTrack,

    # Select which collections to use for isolation.  You can select one or both
    ApplyDiscriminationByECALIsolation=cms.bool(
        False),  # use PFGammas when isolating
    ApplyDiscriminationByTrackerIsolation=cms.bool(
        True),  # use PFChargedHadr when isolating
    applyOccupancyCut=cms.bool(
        True),  # apply a cut on number of isolation objects
    maximumOccupancy=cms.uint32(0),  # no tracks > 1 GeV allowed
    applySumPtCut=cms.bool(
        False),  # apply a cut on the sum Pt of the isolation objects
    maximumSumPtCut=cms.double(6.0),
    applyRelativeSumPtCut=cms.bool(False),  # apply a cut on IsoPt/TotalPt
    relativeSumPtCut=cms.double(0.0),
    qualityCuts=PFTauQualityCuts,  # set the standard quality cuts
)
hltPFRecoTauDiscriminationByIsolation = pfRecoTauDiscriminationByIsolation.clone(
    PFTauProducer = cms.InputTag('hltPFRecoTauProducer'), #tau collection to discriminate

    # Require leading pion ensures that:
    # 1) these is at least one track above threshold (0.5 GeV) in the signal cone
    # 2) a track in the signal cone has pT > 5 GeV
    Prediscriminants = noPrediscriminants,

    # Select which collections to use for isolation. You can select one or both
    ApplyDiscriminationByECALIsolation = cms.bool(False), # use PFGammas when isolating
    ApplyDiscriminationByTrackerIsolation = cms.bool(True), # use PFChargedHadr when isolating

    applyOccupancyCut = cms.bool(True), # apply a cut on number of isolation objects
    maximumOccupancy = cms.uint32(0), # no tracks > 1 GeV or gammas > 1.5 GeV allowed

    applySumPtCut = cms.bool(False), # apply a cut on the sum Pt of the isolation objects
    maximumSumPtCut = cms.double(6.0),
    storeRawSumPt = cms.bool(False),

    applyRelativeSumPtCut = cms.bool(False), # apply a cut on IsoPt/TotalPt
    relativeSumPtCut = cms.double(0.0),

    qualityCuts = hltPFTauQualityCuts,# set the standard quality cuts

    # Delta-Beta corrections to remove Pileup
    applyDeltaBetaCorrection = cms.bool(False),
    particleFlowSrc = cms.InputTag("hltParticleFlow"),
    vertexSrc = hltPFTauQualityCuts.primaryVertexSrc,
    customOuterCone = cms.double( -1.0 ),

    # This must correspond to the cone size of the algorithm which built the
    # tau. (or if customOuterCone option is used, the custom cone size)
    isoConeSizeForDeltaBeta = cms.double(0.3),
    # The delta beta factor maps the expected neutral contribution in the
    # isolation cone from the observed PU charged contribution.  This factor can
    # optionally be a function (use 'x') of the number of vertices in the event
    # (taken from the multiplicity of vertexSrc collection)
    deltaBetaFactor = cms.string("0.38"),
    # By default, the pt threshold for tracks used to compute the DeltaBeta
    # correction is taken as the gamma Et threshold from the isolation quality
    # cuts.
    # Uncommenting the parameter below allows this threshold to be overridden.
    deltaBetaPUTrackPtCutOverride = cms.double(0.5),

    # Rho corrections
    applyRhoCorrection = cms.bool(False),
    rhoProducer = cms.InputTag("kt6PFJets", "rho"),
    rhoConeSize = cms.double(0.5),
    rhoUEOffsetCorrection = cms.double(1.0),
)
예제 #3
0
import FWCore.ParameterSet.Config as cms

from RecoTauTag.RecoTau.PFRecoTauQualityCuts_cfi import PFTauQualityCuts
from RecoTauTag.RecoTau.TauDiscriminatorTools import requireLeadPion
from RecoTauTag.RecoTau.PFRecoTauDiscriminationByIsolation_cfi import pfRecoTauDiscriminationByIsolation

# Cut on sum pt < 8GeV  isolation tracks.

pfRecoTauDiscriminationByIsolationChargedSumPt = pfRecoTauDiscriminationByIsolation.clone(
    PFTauProducer=cms.InputTag('pfRecoTauProducer'),

    # Require leading pion ensures that: theee is at least one track above
    # threshold (0.5 GeV) in the signal cone a track in the signal cone has
    # pT > 5 GeV
    Prediscriminants=requireLeadPion,

    # Select which collections to use for isolation.
    ApplyDiscriminationByECALIsolation=cms.bool(False),
    ApplyDiscriminationByTrackerIsolation=cms.bool(True),
    applyOccupancyCut=cms.bool(False),
    maximumOccupancy=cms.uint32(1),
    applySumPtCut=cms.bool(True),
    maximumSumPtCut=cms.double(8.0),
    applyRelativeSumPtCut=cms.bool(False),
    relativeSumPtCut=cms.double(0.0),

    # Set the standard quality cuts on the isolation candidates
    qualityCuts=PFTauQualityCuts,
    PVProducer=PFTauQualityCuts.primaryVertexSrc  # need for Q cuts
)
from RecoTauTag.RecoTau.TauDiscriminatorTools import requireLeadPion
from RecoTauTag.RecoTau.PFRecoTauDiscriminationByIsolation_cfi import pfRecoTauDiscriminationByIsolation

# Cut on sum pt < 8GeV  isolation tracks.

pfRecoTauDiscriminationByIsolationChargedSumPt = pfRecoTauDiscriminationByIsolation.clone(
    PFTauProducer = cms.InputTag('pfRecoTauProducer'),

    # Require leading pion ensures that: theee is at least one track above
    # threshold (0.5 GeV) in the signal cone a track in the signal cone has
    # pT > 5 GeV
    Prediscriminants = requireLeadPion,

    # Select which collections to use for isolation.
    ApplyDiscriminationByECALIsolation = cms.bool(False),
    ApplyDiscriminationByTrackerIsolation = cms.bool(True),

    applyOccupancyCut = cms.bool(False),
    maximumOccupancy = cms.uint32(1),

    applySumPtCut = cms.bool(True),
    maximumSumPtCut = cms.double(8.0),

    applyRelativeSumPtCut = cms.bool(False),
    relativeSumPtCut = cms.double(0.0),

    # Set the standard quality cuts on the isolation candidates
    qualityCuts = PFTauQualityCuts,
    PVProducer = PFTauQualityCuts.primaryVertexSrc  # need for Q cuts
)
def addPFTauDiscriminatorsForDeepTau(process, srcPFTaus, srcPFCandidates,
                                     srcVertices, pftauQualityCuts,
                                     pftauSequence, pfTauLabel, suffix):

    hltPFTauDiscriminationByDecayModeFindingNewDMs = addPFTauDiscriminator(
        process,
        "hlt%sDiscriminationByDecayModeFindingNewDMs%s" % (pfTauLabel, suffix),
        hpsSelectionDiscriminator.clone(
            PFTauProducer=cms.InputTag(srcPFTaus),
            decayModes=cms.VPSet(decayMode_1Prong0Pi0, decayMode_1Prong1Pi0,
                                 decayMode_1Prong2Pi0, decayMode_2Prong0Pi0,
                                 decayMode_2Prong1Pi0, decayMode_3Prong0Pi0,
                                 decayMode_3Prong1Pi0),
            requireTauChargedHadronsToBeChargedPFCands=cms.bool(True),
            minPixelHits=cms.int32(1)), pftauSequence)
    srcPFTauDiscriminationByDecayModeFindingNewDMs = hltPFTauDiscriminationByDecayModeFindingNewDMs.label(
    )

    requireDecayMode = cms.PSet(
        BooleanOperator=cms.string("and"),
        decayMode=cms.PSet(Producer=cms.InputTag(
            srcPFTauDiscriminationByDecayModeFindingNewDMs),
                           cut=cms.double(0.5)))

    hpsPFTauBasicDiscriminators = addPFTauDiscriminator(
        process,
        "hlt%sBasicDiscriminators%s" % (pfTauLabel, suffix),
        pfRecoTauDiscriminationByIsolation.clone(
            PFTauProducer=cms.InputTag(srcPFTaus),
            particleFlowSrc=cms.InputTag(srcPFCandidates),
            vertexSrc=cms.InputTag(srcVertices),
            Prediscriminants=requireDecayMode,
            deltaBetaPUTrackPtCutOverride=
            True,  # Set the boolean = True to override.
            deltaBetaPUTrackPtCutOverride_val=
            0.5,  # Set the value for new value.
            customOuterCone=0.5,
            isoConeSizeForDeltaBeta=0.8,
            deltaBetaFactor="0.20",
            qualityCuts=pftauQualityCuts,
            IDdefinitions=cms.VPSet(
                cms.PSet(IDname=cms.string("ChargedIsoPtSum"),
                         ApplyDiscriminationByTrackerIsolation=cms.bool(True),
                         storeRawSumPt=cms.bool(True)),
                cms.PSet(IDname=cms.string("NeutralIsoPtSum"),
                         ApplyDiscriminationByECALIsolation=cms.bool(True),
                         storeRawSumPt=cms.bool(True)),
                cms.PSet(
                    IDname=cms.string("NeutralIsoPtSumWeight"),
                    ApplyDiscriminationByWeightedECALIsolation=cms.bool(True),
                    storeRawSumPt=cms.bool(True),
                    UseAllPFCandsForWeights=cms.bool(True)),
                cms.PSet(IDname=cms.string("TauFootprintCorrection"),
                         storeRawFootprintCorrection=cms.bool(True)),
                cms.PSet(IDname=cms.string("PhotonPtSumOutsideSignalCone"),
                         storeRawPhotonSumPt_outsideSignalCone=cms.bool(True)),
                cms.PSet(IDname=cms.string("PUcorrPtSum"),
                         applyDeltaBetaCorrection=cms.bool(True),
                         storeRawPUsumPt=cms.bool(True)),
                cms.PSet(IDname=cms.string(
                    "ByRawCombinedIsolationDBSumPtCorr3Hits"),
                         ApplyDiscriminationByTrackerIsolation=cms.bool(True),
                         ApplyDiscriminationByECALIsolation=cms.bool(True),
                         applyDeltaBetaCorrection=cms.bool(True),
                         storeRawSumPt=cms.bool(True)))),
        pftauSequence)

    hpsPFTauBasicDiscriminatorsdR03 = addPFTauDiscriminator(
        process,
        "hlt%sBasicDiscriminatorsdR03%s" % (pfTauLabel, suffix),
        hpsPFTauBasicDiscriminators.clone(
            customOuterCone=0.3,
            deltaBetaFactor='0.0720'  # 0.2*(0.3/0.5)^2
        ),
        pftauSequence)

    return srcPFTauDiscriminationByDecayModeFindingNewDMs
from RecoTauTag.RecoTau.PFRecoTauQualityCuts_cfi import PFTauQualityCuts
from RecoTauTag.RecoTau.TauDiscriminatorTools import requireLeadTrack
from RecoTauTag.RecoTau.PFRecoTauDiscriminationByIsolation_cfi import  pfRecoTauDiscriminationByIsolation

pfRecoTauDiscriminationByTrackIsolation = pfRecoTauDiscriminationByIsolation.clone(

    PFTauProducer = cms.InputTag('pfRecoTauProducer'), #tau collection to discriminate

    # Require leading pion ensures that:
    #  1) these is at least one track above threshold (0.5 GeV) in the signal cone
    #  2) a track in the signal cone has pT > 5 GeV
    Prediscriminants = requireLeadTrack,

    # Select which collections to use for isolation.  You can select one or both
    ApplyDiscriminationByECALIsolation    = cms.bool(False),  # use PFGammas when isolating
    ApplyDiscriminationByTrackerIsolation = cms.bool(True),   # use PFChargedHadr when isolating

    applyOccupancyCut                     = cms.bool(True),  # apply a cut on number of isolation objects
    maximumOccupancy                      = cms.uint32(0),   # no tracks > 1 GeV allowed

    applySumPtCut                         = cms.bool(False), # apply a cut on the sum Pt of the isolation objects
    maximumSumPtCut                       = cms.double(6.0),

    applyRelativeSumPtCut                 = cms.bool(False), # apply a cut on IsoPt/TotalPt
    relativeSumPtCut                      = cms.double(0.0),

    qualityCuts                           = PFTauQualityCuts,# set the standard quality cuts
)

예제 #7
0
hltPFRecoTauDiscriminationByIsolation = pfRecoTauDiscriminationByIsolation.clone(
    PFTauProducer='hltPFRecoTauProducer',  #tau collection to discriminate

    # Require leading pion ensures that:
    # 1) these is at least one track above threshold (0.5 GeV) in the signal cone
    # 2) a track in the signal cone has pT > 5 GeV
    Prediscriminants=noPrediscriminants,
    qualityCuts=hltPFTauQualityCuts,  # set the standard quality cuts

    # Delta-Beta corrections to remove Pileup
    particleFlowSrc="hltParticleFlow",
    vertexSrc=hltPFTauQualityCuts.primaryVertexSrc,
    customOuterCone=-1.0,

    # This must correspond to the cone size of the algorithm which built the
    # tau. (or if customOuterCone option is used, the custom cone size)
    isoConeSizeForDeltaBeta=0.3,
    # The delta beta factor maps the expected neutral contribution in the
    # isolation cone from the observed PU charged contribution.  This factor can
    # optionally be a function (use 'x') of the number of vertices in the event
    # (taken from the multiplicity of vertexSrc collection)
    deltaBetaFactor="0.38",
    # By default, the pt threshold for tracks used to compute the DeltaBeta
    # correction is taken as the gamma Et threshold from the isolation quality
    # cuts.
    deltaBetaPUTrackPtCutOverride=True,  # Set the boolean = True to override.
    deltaBetaPUTrackPtCutOverride_val=0.5,  # Set the value for new value.

    # Rho corrections
    applyRhoCorrection=False,
    rhoProducer="kt6PFJets:rho",
    rhoConeSize=0.5,
    rhoUEOffsetCorrection=1.0,
    IDdefinitions=cms.VPSet(),
    IDWPdefinitions=cms.VPSet(
        cms.PSet(
            IDname=cms.string("pfRecoTauDiscriminationByIsolation"),
            maximumOccupancy=cms.uint32(
                0),  # no tracks > 1 GeV or gammas > 1.5 GeV allowed
            ApplyDiscriminationByTrackerIsolation=cms.bool(
                True),  # use PFGammas when isolating
        )),
)