CMS 3D CMS Logo
Functions | Variables

PFRecoTauDiscriminationForChargedHiggs_cfi Namespace Reference

Functions

def addDiscriminator
def addDiscriminatorSequence
def addPFTauDiscriminationSequenceForChargedHiggs

Variables

tuple hplusTrackQualityCuts = PFTauQualityCuts.clone()

Function Documentation

def PFRecoTauDiscriminationForChargedHiggs_cfi::addDiscriminator (   process,
  tau,
  name,
  module 
)

Definition at line 22 of file PFRecoTauDiscriminationForChargedHiggs_cfi.py.

00023                                                 :
00024     producerPostfix = ""
00025     if tau != "hpsTancTaus":
00026         producerPostfix = "Producer"
00027     module.PFTauProducer = cms.InputTag(tau+producerPostfix)
00028     process.__setattr__(tau+name, module)
00029     return module
def PFRecoTauDiscriminationForChargedHiggs_cfi::addDiscriminatorSequence (   process,
  tau 
)

Definition at line 30 of file PFRecoTauDiscriminationForChargedHiggs_cfi.py.

00031                                           :
00032     leadingTrackFinding = tau+"DiscriminationByLeadingTrackFinding"
00033     if tau == "hpsPFTau":
00034         leadingTrackFinding = tau+"DiscriminationByDecayModeFinding"
00035     
00036     lst = []
00037 
00038     lst.append(addDiscriminator(process, tau, "DiscriminationForChargedHiggsByLeadingTrackPtCut",
00039                                 pfRecoTauDiscriminationByLeadingTrackPtCut.clone(
00040                                    MinPtLeadingObject = cms.double(20.0),
00041                                    qualityCuts = hplusTrackQualityCuts
00042                                    )))
00043 
00044     lst.append(addDiscriminator(process, tau, "DiscriminationByCharge", 
00045                                 pfRecoTauDiscriminationByCharge.clone()))
00046 
00047     # index -1 points to the last element in the list
00048     lst.append(addDiscriminator(process, tau, "DiscriminationForChargedHiggsByECALIsolation", 
00049                                 pfRecoTauDiscriminationByECALIsolation.clone()))
00050     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00051 
00052     lst.append(addDiscriminator(process, tau, "DiscriminationForChargedHiggsAgainstElectron",
00053                                 pfRecoTauDiscriminationAgainstElectron.clone()))
00054     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00055 
00056     lst.append(addDiscriminator(process, tau, "DiscriminationForChargedHiggsAgainstMuon",
00057                                 pfRecoTauDiscriminationAgainstMuon.clone()))
00058     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00059 
00060     lst.append(addDiscriminator(process, tau, "DiscriminationByTauPolarization",
00061                                 pfRecoTauDiscriminationByTauPolarization.clone()))
00062     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00063 
00064     lst.append(addDiscriminator(process, tau, "DiscriminationByDeltaE",
00065                                 pfRecoTauDiscriminationByDeltaE.clone()))
00066     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00067     
00068     lst.append(addDiscriminator(process, tau, "DiscriminationByInvMass",
00069                                 pfRecoTauDiscriminationByInvMass.clone()))
00070     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00071 
00072     lst.append(addDiscriminator(process, tau, "DiscriminationByFlightPathSignificance",
00073                                 pfRecoTauDiscriminationByFlightPathSignificance.clone()))
00074     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00075 
00076     lst.append(addDiscriminator(process, tau, "DiscriminationBy1Prong",
00077                                 pfRecoTauDiscriminationByNProngs.clone(
00078                                   nProngs = cms.uint32(1)
00079                                   )))
00080     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00081 
00082     lst.append(addDiscriminator(process, tau, "DiscriminationBy3Prongs",
00083                                 pfRecoTauDiscriminationByNProngs.clone(
00084                                   nProngs = cms.uint32(3)
00085                                   )))
00086     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00087 
00088     lst.append(addDiscriminator(process, tau, "DiscriminationForChargedHiggsBy3ProngCombined",
00089                                 pfRecoTauDiscriminationByNProngs.clone(
00090                                   nProngs = cms.uint32(3),
00091                                   Prediscriminants = cms.PSet(
00092                                        BooleanOperator = cms.string("and"),
00093                                        leadTrack = cms.PSet(
00094                                            Producer = cms.InputTag(leadingTrackFinding),
00095                                            cut = cms.double(0.5)
00096                                        ),
00097                                        deltaE = cms.PSet(
00098                                            Producer = cms.InputTag(tau+'DiscriminationByDeltaE'),
00099                                            cut = cms.double(0.5)
00100                                        ),
00101                                        invMass = cms.PSet(
00102                                            Producer = cms.InputTag(tau+'DiscriminationByInvMass'),
00103                                            cut = cms.double(0.5)
00104                                        ),
00105                                        flightPathSig = cms.PSet(
00106                                            Producer = cms.InputTag(tau+'DiscriminationByFlightPathSignificance'),
00107                                            cut = cms.double(0.5)
00108                                        )
00109                                   )
00110                                 )))
00111     lst[-1].Prediscriminants.leadTrack.Producer = cms.InputTag(leadingTrackFinding)
00112 
00113     lst.append(addDiscriminator(process, tau, "DiscriminationForChargedHiggsBy1or3Prongs",
00114                                 pfRecoTauDiscriminationByLeadingTrackFinding.clone(
00115                                     Prediscriminants = cms.PSet(
00116                                         BooleanOperator = cms.string("or"),
00117                                         oneProng = cms.PSet(
00118                                             Producer = cms.InputTag(tau+'DiscriminationBy1Prong'),
00119                                             cut = cms.double(0.5)
00120                                         ),
00121                                         threeProng = cms.PSet(
00122                                             Producer = cms.InputTag(tau+'DiscriminationForChargedHiggsBy3ProngCombined'),
00123                                             cut = cms.double(0.5)
00124                                         )
00125                                     )
00126                                 )))
00127     lst.append(addDiscriminator(process, tau, "DiscriminationForChargedHiggs",
00128                                 pfRecoTauDiscriminationByTrackIsolation.clone(
00129                                      Prediscriminants = cms.PSet(
00130                                         BooleanOperator = cms.string("and"),
00131                                         leadingTrack = cms.PSet(
00132                                             Producer = cms.InputTag(tau+'DiscriminationForChargedHiggsByLeadingTrackPtCut'),
00133                                             cut = cms.double(0.5)
00134                                         ),
00135                                         charge = cms.PSet(
00136                                             Producer = cms.InputTag(tau+'DiscriminationByCharge'),
00137                                             cut = cms.double(0.5)
00138                                         ),
00139                                         ecalIsolation = cms.PSet(
00140                                             Producer = cms.InputTag(tau+'DiscriminationForChargedHiggsByECALIsolation'),
00141                                             cut = cms.double(0.5)
00142                                         ),
00143                                         electronVeto = cms.PSet(
00144                                             Producer = cms.InputTag(tau+'DiscriminationForChargedHiggsAgainstElectron'),
00145                                             cut = cms.double(0.5)
00146                                         ),
00147                                         polarization = cms.PSet(
00148                                             Producer = cms.InputTag(tau+'DiscriminationByTauPolarization'),
00149                                             cut = cms.double(0.5)
00150                                         ),
00151                                         prongs = cms.PSet(
00152                                             Producer = cms.InputTag(tau+'DiscriminationForChargedHiggsBy1or3Prongs'),
00153                                             cut = cms.double(0.5)
00154                                         )
00155                                     )
00156                                 )))
00157 
00158     sequence = cms.Sequence()
00159     for m in lst:
00160         sequence *= m
00161 
00162     process.__setattr__(tau+"HplusDiscriminationSequence", sequence)
00163     return sequence
def PFRecoTauDiscriminationForChargedHiggs_cfi::addPFTauDiscriminationSequenceForChargedHiggs (   process,
  tauAlgos = ["shrinkingConePFTau"] 
)

Definition at line 164 of file PFRecoTauDiscriminationForChargedHiggs_cfi.py.

00165                                                                                            :
00166     process.PFTauDiscriminationSequenceForChargedHiggs = cms.Sequence()
00167     for algo in tauAlgos:
00168         process.PFTauDiscriminationSequenceForChargedHiggs *= addDiscriminatorSequence(process, algo)
00169 
00170     return process.PFTauDiscriminationSequenceForChargedHiggs

Variable Documentation

tuple PFRecoTauDiscriminationForChargedHiggs_cfi::hplusTrackQualityCuts = PFTauQualityCuts.clone()

Definition at line 5 of file PFRecoTauDiscriminationForChargedHiggs_cfi.py.

Generated for CMSSW Reference Manual by doxygen 1.7.3