From 8f55d733315824bd1c5d04c2888bbd322cc6a2ac Mon Sep 17 00:00:00 2001 From: sandeepbhowmik1 Date: Sun, 25 Apr 2021 21:06:47 +0300 Subject: [PATCH] Uploaded HPS Tau algorithm for new PR --- DataFormats/Phase2L1Taus/BuildFile.xml | 6 + .../Phase2L1Taus/interface/L1HPSPFTau.h | 210 +++++++++ .../Phase2L1Taus/interface/L1HPSPFTauFwd.h | 10 + DataFormats/Phase2L1Taus/src/L1HPSPFTau.cc | 84 ++++ DataFormats/Phase2L1Taus/src/classes.h | 4 + DataFormats/Phase2L1Taus/src/classes_def.xml | 7 + L1Trigger/Phase2L1Taus/BuildFile.xml | 39 ++ .../interface/L1HPSPFTauBuilder.h | 103 ++++ .../interface/L1HPSPFTauProducer.h | 69 +++ .../interface/L1HPSPFTauQualityCut.h | 46 ++ L1Trigger/Phase2L1Taus/plugins/BuildFile.xml | 10 + .../plugins/L1HPSPFTauProducer.cc | 217 +++++++++ .../python/L1HPSPFTauProducerPF_cfi.py | 71 +++ .../python/L1HPSPFTauProducerPuppi_cfi.py | 71 +++ .../Phase2L1Taus/python/l1emulator_cff.py | 47 ++ .../Phase2L1Taus/src/L1HPSPFTauBuilder.cc | 446 ++++++++++++++++++ .../Phase2L1Taus/src/L1HPSPFTauQualityCut.cc | 105 +++++ .../test/produceL1HPSPFTaus_cfg.py | 207 ++++++++ 18 files changed, 1752 insertions(+) create mode 100644 DataFormats/Phase2L1Taus/BuildFile.xml create mode 100644 DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h create mode 100644 DataFormats/Phase2L1Taus/interface/L1HPSPFTauFwd.h create mode 100644 DataFormats/Phase2L1Taus/src/L1HPSPFTau.cc create mode 100644 DataFormats/Phase2L1Taus/src/classes.h create mode 100644 DataFormats/Phase2L1Taus/src/classes_def.xml create mode 100644 L1Trigger/Phase2L1Taus/BuildFile.xml create mode 100644 L1Trigger/Phase2L1Taus/interface/L1HPSPFTauBuilder.h create mode 100644 L1Trigger/Phase2L1Taus/interface/L1HPSPFTauProducer.h create mode 100644 L1Trigger/Phase2L1Taus/interface/L1HPSPFTauQualityCut.h create mode 100644 L1Trigger/Phase2L1Taus/plugins/BuildFile.xml create mode 100644 L1Trigger/Phase2L1Taus/plugins/L1HPSPFTauProducer.cc create mode 100644 L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPF_cfi.py create mode 100644 L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPuppi_cfi.py create mode 100644 L1Trigger/Phase2L1Taus/python/l1emulator_cff.py create mode 100644 L1Trigger/Phase2L1Taus/src/L1HPSPFTauBuilder.cc create mode 100644 L1Trigger/Phase2L1Taus/src/L1HPSPFTauQualityCut.cc create mode 100644 L1Trigger/Phase2L1Taus/test/produceL1HPSPFTaus_cfg.py diff --git a/DataFormats/Phase2L1Taus/BuildFile.xml b/DataFormats/Phase2L1Taus/BuildFile.xml new file mode 100644 index 0000000000000..9296748188006 --- /dev/null +++ b/DataFormats/Phase2L1Taus/BuildFile.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h b/DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h new file mode 100644 index 0000000000000..cf8a62de45255 --- /dev/null +++ b/DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h @@ -0,0 +1,210 @@ +#ifndef DataFormats_Phase2L1Taus_L1HPSPFTau_H +#define DataFormats_Phase2L1Taus_L1HPSPFTau_H + +#include "DataFormats/L1TParticleFlow/interface/PFCandidate.h" // l1t::PFCandidate, l1t::PFCandidateRef, l1t::PFCandidateRefVector +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/Candidate/interface/LeafCandidate.h" // reco::LeafCandidate +#include "DataFormats/Candidate/interface/Particle.h" // reco::Particle::LorentzVector +#include "DataFormats/L1TCorrelator/interface/TkPrimaryVertex.h" + +#include + +namespace l1t { + + class L1HPSPFTau : public reco::LeafCandidate { + public: + /// default constructor + L1HPSPFTau(); + + /// destructor + ~L1HPSPFTau(); + + /// accessor functions for reco level quantities + bool isChargedPFCandSeeded() const { return seedChargedPFCand_.isNonnull(); } + bool isJetSeeded() const { return seedJet_.isNonnull(); } + + const l1t::PFCandidateRef& seedChargedPFCand() const { return seedChargedPFCand_; } + const reco::CaloJetRef& seedJet() const { return seedJet_; } + const l1t::PFCandidateRef& leadChargedPFCand() const { return leadChargedPFCand_; } + + const l1t::PFCandidateRefVector& signalAllL1PFCandidates() const { return signalAllL1PFCandidates_; } + const l1t::PFCandidateRefVector& signalChargedHadrons() const { return signalChargedHadrons_; } + const l1t::PFCandidateRefVector& signalElectrons() const { return signalElectrons_; } + const l1t::PFCandidateRefVector& signalNeutralHadrons() const { return signalNeutralHadrons_; } + const l1t::PFCandidateRefVector& signalPhotons() const { return signalPhotons_; } + const l1t::PFCandidateRefVector& signalMuons() const { return signalMuons_; } + + const l1t::PFCandidateRefVector& stripAllL1PFCandidates() const { return stripAllL1PFCandidates_; } + const l1t::PFCandidateRefVector& stripElectrons() const { return stripElectrons_; } + const l1t::PFCandidateRefVector& stripPhotons() const { return stripPhotons_; } + + const l1t::PFCandidateRefVector& isoAllL1PFCandidates() const { return isoAllL1PFCandidates_; } + const l1t::PFCandidateRefVector& isoChargedHadrons() const { return isoChargedHadrons_; } + const l1t::PFCandidateRefVector& isoElectrons() const { return isoElectrons_; } + const l1t::PFCandidateRefVector& isoNeutralHadrons() const { return isoNeutralHadrons_; } + const l1t::PFCandidateRefVector& isoPhotons() const { return isoPhotons_; } + const l1t::PFCandidateRefVector& isoMuons() const { return isoMuons_; } + + const l1t::PFCandidateRefVector& sumAllL1PFCandidates() const { return sumAllL1PFCandidates_; } + const l1t::PFCandidateRefVector& sumChargedHadrons() const { return sumChargedHadrons_; } + const l1t::PFCandidateRefVector& sumElectrons() const { return sumElectrons_; } + const l1t::PFCandidateRefVector& sumNeutralHadrons() const { return sumNeutralHadrons_; } + const l1t::PFCandidateRefVector& sumPhotons() const { return sumPhotons_; } + const l1t::PFCandidateRefVector& sumMuons() const { return sumMuons_; } + + const l1t::TkPrimaryVertexRef& primaryVertex() const { return primaryVertex_; } + + enum Kind { kUndefined, kOneProng0Pi0, kOneProng1Pi0, kThreeProng0Pi0, kThreeProng1Pi0 }; + Kind tauType() const { return tauType_; } + + const reco::Particle::LorentzVector& stripP4() const { return stripP4_; } + + float sumAllL1PFCandidatesPt() const { return sumAllL1PFCandidatesPt_; } + float signalConeSize() const { return signalConeSize_; } + float isolationConeSize() const { return signalConeSize_; } + + float sumChargedIso() const { return sumChargedIso_; } + float sumNeutralIso() const { return sumNeutralIso_; } + float sumCombinedIso() const { return sumCombinedIso_; } + float sumChargedIsoPileup() const { return sumChargedIsoPileup_; } + + bool passTightIso() const { return passTightIso_; } + bool passMediumIso() const { return passMediumIso_; } + bool passLooseIso() const { return passLooseIso_; } + bool passVLooseIso() const { return passVLooseIso_; } + + bool passTightRelIso() const { return passTightRelIso_; } + bool passMediumRelIso() const { return passMediumRelIso_; } + bool passLooseRelIso() const { return passLooseRelIso_; } + bool passVLooseRelIso() const { return passVLooseRelIso_; } + + void setSeedChargedPFCand(l1t::PFCandidateRef seedChargedPFCand) { seedChargedPFCand_ = seedChargedPFCand; } + void setSeedJet(reco::CaloJetRef seedJet) { seedJet_ = seedJet; } + void setLeadChargedPFCand(l1t::PFCandidateRef leadChargedPFCand) { leadChargedPFCand_ = leadChargedPFCand; } + + void setSignalAllL1PFCandidates(l1t::PFCandidateRefVector signalAllL1PFCandidates) { + signalAllL1PFCandidates_ = signalAllL1PFCandidates; + } + void setSignalChargedHadrons(l1t::PFCandidateRefVector signalChargedHadrons) { + signalChargedHadrons_ = signalChargedHadrons; + } + void setSignalElectrons(l1t::PFCandidateRefVector signalElectrons) { signalElectrons_ = signalElectrons; } + void setSignalNeutralHadrons(l1t::PFCandidateRefVector signalNeutralHadrons) { + signalNeutralHadrons_ = signalNeutralHadrons; + } + void setSignalPhotons(l1t::PFCandidateRefVector signalPhotons) { signalPhotons_ = signalPhotons; } + void setSignalMuons(l1t::PFCandidateRefVector signalMuons) { signalMuons_ = signalMuons; } + + void setStripAllL1PFCandidates(l1t::PFCandidateRefVector stripAllL1PFCandidates) { + stripAllL1PFCandidates_ = stripAllL1PFCandidates; + } + void setStripElectrons(l1t::PFCandidateRefVector stripElectrons) { stripElectrons_ = stripElectrons; } + void setStripPhotons(l1t::PFCandidateRefVector stripPhotons) { stripPhotons_ = stripPhotons; } + + void setIsoAllL1PFCandidates(l1t::PFCandidateRefVector isoAllL1PFCandidates) { + isoAllL1PFCandidates_ = isoAllL1PFCandidates; + } + void setIsoChargedHadrons(l1t::PFCandidateRefVector isoChargedHadrons) { isoChargedHadrons_ = isoChargedHadrons; } + void setIsoElectrons(l1t::PFCandidateRefVector isoElectrons) { isoElectrons_ = isoElectrons; } + void setIsoNeutralHadrons(l1t::PFCandidateRefVector isoNeutralHadrons) { isoNeutralHadrons_ = isoNeutralHadrons; } + void setIsoPhotons(l1t::PFCandidateRefVector isoPhotons) { isoPhotons_ = isoPhotons; } + void setIsoMuons(l1t::PFCandidateRefVector isoMuons) { isoMuons_ = isoMuons; } + + void setSumAllL1PFCandidates(l1t::PFCandidateRefVector sumAllL1PFCandidates) { + sumAllL1PFCandidates_ = sumAllL1PFCandidates; + } + void setSumChargedHadrons(l1t::PFCandidateRefVector sumChargedHadrons) { sumChargedHadrons_ = sumChargedHadrons; } + void setSumElectrons(l1t::PFCandidateRefVector sumElectrons) { sumElectrons_ = sumElectrons; } + void setSumNeutralHadrons(l1t::PFCandidateRefVector sumNeutralHadrons) { sumNeutralHadrons_ = sumNeutralHadrons; } + void setSumPhotons(l1t::PFCandidateRefVector sumPhotons) { sumPhotons_ = sumPhotons; } + void setSumMuons(l1t::PFCandidateRefVector sumMuons) { sumMuons_ = sumMuons; } + + void setPrimaryVertex(l1t::TkPrimaryVertexRef primaryVertex) { primaryVertex_ = primaryVertex; } + + void setTauType(Kind tauType) { tauType_ = tauType; } + + void setStripP4(reco::Particle::LorentzVector& stripP4) { stripP4_ = stripP4; } + + void setSumAllL1PFCandidatesPt(float sumAllL1PFCandidatesPt) { sumAllL1PFCandidatesPt_ = sumAllL1PFCandidatesPt; } + void setSignalConeSize(float signalConeSize) { signalConeSize_ = signalConeSize; } + void setisolationConeSize(float isolationConeSize) { signalConeSize_ = isolationConeSize; } + + void setSumChargedIso(float sumChargedIso) { sumChargedIso_ = sumChargedIso; } + void setSumNeutralIso(float sumNeutralIso) { sumNeutralIso_ = sumNeutralIso; } + void setSumCombinedIso(float sumCombinedIso) { sumCombinedIso_ = sumCombinedIso; } + void setSumChargedIsoPileup(float sumChargedIsoPileup) { sumChargedIsoPileup_ = sumChargedIsoPileup; } + + void setPassTightIso(bool passTightIso) { passTightIso_ = passTightIso; } + void setPassMediumIso(bool passMediumIso) { passMediumIso_ = passMediumIso; } + void setPassLooseIso(bool passLooseIso) { passLooseIso_ = passLooseIso; } + void setPassVLooseIso(bool passVLooseIso) { passVLooseIso_ = passVLooseIso; } + + void setPassTightRelIso(bool passTightRelIso) { passTightRelIso_ = passTightRelIso; } + void setPassMediumRelIso(bool passMediumRelIso) { passMediumRelIso_ = passMediumRelIso; } + void setPassLooseRelIso(bool passLooseRelIso) { passLooseRelIso_ = passLooseRelIso; } + void setPassVLooseRelIso(bool passVLooseRelIso) { passVLooseRelIso_ = passVLooseRelIso; } + + private: + l1t::PFCandidateRef seedChargedPFCand_; + reco::CaloJetRef seedJet_; + l1t::PFCandidateRef leadChargedPFCand_; + + l1t::PFCandidateRefVector signalAllL1PFCandidates_; + l1t::PFCandidateRefVector signalChargedHadrons_; + l1t::PFCandidateRefVector signalElectrons_; + l1t::PFCandidateRefVector signalNeutralHadrons_; + l1t::PFCandidateRefVector signalPhotons_; + l1t::PFCandidateRefVector signalMuons_; + + l1t::PFCandidateRefVector stripAllL1PFCandidates_; + l1t::PFCandidateRefVector stripElectrons_; + l1t::PFCandidateRefVector stripPhotons_; + + l1t::PFCandidateRefVector isoAllL1PFCandidates_; + l1t::PFCandidateRefVector isoChargedHadrons_; + l1t::PFCandidateRefVector isoElectrons_; + l1t::PFCandidateRefVector isoNeutralHadrons_; + l1t::PFCandidateRefVector isoPhotons_; + l1t::PFCandidateRefVector isoMuons_; + + l1t::PFCandidateRefVector sumAllL1PFCandidates_; + l1t::PFCandidateRefVector sumChargedHadrons_; + l1t::PFCandidateRefVector sumElectrons_; + l1t::PFCandidateRefVector sumNeutralHadrons_; + l1t::PFCandidateRefVector sumPhotons_; + l1t::PFCandidateRefVector sumMuons_; + + l1t::TkPrimaryVertexRef primaryVertex_; + Kind tauType_; + + reco::Particle::LorentzVector stripP4_; + + float sumAllL1PFCandidatesPt_; + float signalConeSize_; + float isolationConeSize_; + + float sumChargedIso_; + float sumNeutralIso_; + float sumCombinedIso_; + float sumChargedIsoPileup_; // charged PFCands failing dz cut (maybe useful to correct neutral isolation for pile-up contributions by applying delta-beta corrections) + + bool passTightIso_; + bool passMediumIso_; + bool passLooseIso_; + bool passVLooseIso_; + + bool passTightRelIso_; + bool passMediumRelIso_; + bool passLooseRelIso_; + bool passVLooseRelIso_; + }; + +} // namespace l1t + +/// print to stream +std::ostream& operator<<(std::ostream& os, const l1t::L1HPSPFTau& l1PFTau); + +void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, const l1t::TkPrimaryVertexRef& primaryVertex); +void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, float primaryVertexZ); + +#endif diff --git a/DataFormats/Phase2L1Taus/interface/L1HPSPFTauFwd.h b/DataFormats/Phase2L1Taus/interface/L1HPSPFTauFwd.h new file mode 100644 index 0000000000000..334139c35cd63 --- /dev/null +++ b/DataFormats/Phase2L1Taus/interface/L1HPSPFTauFwd.h @@ -0,0 +1,10 @@ +#ifndef DataFormats_Phase2L1Taus_L1HPSPFTauFwd_H +#define DataFormats_Phase2L1Taus_L1HPSPFTauFwd_H + +#include "DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h" + +namespace l1t { + typedef std::vector L1HPSPFTauCollection; +} + +#endif diff --git a/DataFormats/Phase2L1Taus/src/L1HPSPFTau.cc b/DataFormats/Phase2L1Taus/src/L1HPSPFTau.cc new file mode 100644 index 0000000000000..de522dff74f5b --- /dev/null +++ b/DataFormats/Phase2L1Taus/src/L1HPSPFTau.cc @@ -0,0 +1,84 @@ +#include "DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h" + +// default constructor +l1t::L1HPSPFTau::L1HPSPFTau() + : tauType_(kUndefined), + sumChargedIso_(0.), + sumNeutralIso_(0.), + sumCombinedIso_(0.), + sumChargedIsoPileup_(0.), + passTightIso_(false), + passMediumIso_(false), + passLooseIso_(false), + passVLooseIso_(false), + passTightRelIso_(false), + passMediumRelIso_(false), + passLooseRelIso_(false), + passVLooseRelIso_(false) {} + +// destructor +l1t::L1HPSPFTau::~L1HPSPFTau() {} + +// print to stream +ostream& operator<<(ostream& os, const l1t::L1HPSPFTau& l1PFTau) { + os << "pT = " << l1PFTau.pt() << ", eta = " << l1PFTau.eta() << ", phi = " << l1PFTau.phi() + << " (type = " << l1PFTau.tauType() << ")" << std::endl; + os << "lead. ChargedPFCand:" << std::endl; + if (l1PFTau.leadChargedPFCand().isNonnull()) { + printPFCand(os, *l1PFTau.leadChargedPFCand(), l1PFTau.primaryVertex()); + } else { + os << " N/A" << std::endl; + } + os << "seed:"; + if (l1PFTau.isChargedPFCandSeeded()) { + os << " chargedPFCand"; + } else if (l1PFTau.isJetSeeded()) { + os << " PFJet"; + } else + assert(0); + os << std::endl; + os << "signalPFCands:" << std::endl; + for (auto l1PFCand : l1PFTau.signalAllL1PFCandidates()) { + printPFCand(os, *l1PFCand, l1PFTau.primaryVertex()); + } + os << "stripPFCands:" << std::endl; + for (auto l1PFCand : l1PFTau.stripAllL1PFCandidates()) { + printPFCand(os, *l1PFCand, l1PFTau.primaryVertex()); + } + os << "strip pT = " << l1PFTau.stripP4().pt() << std::endl; + os << "isolationPFCands:" << std::endl; + for (auto l1PFCand : l1PFTau.isoAllL1PFCandidates()) { + printPFCand(os, *l1PFCand, l1PFTau.primaryVertex()); + } + os << "isolation pT-sum: charged = " << l1PFTau.sumChargedIso() << ", neutral = " << l1PFTau.sumNeutralIso() + << " (charged from pileup = " << l1PFTau.sumChargedIsoPileup() << ")" << std::endl; + return os; +} + +void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, const l1t::TkPrimaryVertexRef& primaryVertex) { + float primaryVertexZ = (primaryVertex.isNonnull()) ? primaryVertex->zvertex() : 0.; + printPFCand(os, l1PFCand, primaryVertexZ); +} + +void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, float primaryVertexZ) { + std::string typeString; + if (l1PFCand.id() == l1t::PFCandidate::ChargedHadron) + typeString = "PFChargedHadron"; + else if (l1PFCand.id() == l1t::PFCandidate::Electron) + typeString = "PFElectron"; + else if (l1PFCand.id() == l1t::PFCandidate::NeutralHadron) + typeString = "PFNeutralHadron"; + else if (l1PFCand.id() == l1t::PFCandidate::Photon) + typeString = "PFPhoton"; + else if (l1PFCand.id() == l1t::PFCandidate::Muon) + typeString = "PFMuon"; + else + typeString = "N/A"; + os << " " << typeString << " with pT = " << l1PFCand.pt() << ", eta = " << l1PFCand.eta() + << ", phi = " << l1PFCand.phi() << "," + << " mass = " << l1PFCand.mass() << ", charge = " << l1PFCand.charge(); + if (l1PFCand.charge() != 0 && primaryVertexZ != 0.) { + os << " (dz = " << std::fabs(l1PFCand.pfTrack()->vertex().z() - primaryVertexZ) << ")"; + } + os << std::endl; +} diff --git a/DataFormats/Phase2L1Taus/src/classes.h b/DataFormats/Phase2L1Taus/src/classes.h new file mode 100644 index 0000000000000..ff542e176ec9e --- /dev/null +++ b/DataFormats/Phase2L1Taus/src/classes.h @@ -0,0 +1,4 @@ +#include "Rtypes.h" + +#include "DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h" +#include "DataFormats/Phase2L1Taus/interface/L1HPSPFTauFwd.h" diff --git a/DataFormats/Phase2L1Taus/src/classes_def.xml b/DataFormats/Phase2L1Taus/src/classes_def.xml new file mode 100644 index 0000000000000..c0cda7a3a7694 --- /dev/null +++ b/DataFormats/Phase2L1Taus/src/classes_def.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/L1Trigger/Phase2L1Taus/BuildFile.xml b/L1Trigger/Phase2L1Taus/BuildFile.xml new file mode 100644 index 0000000000000..5217e02cbc092 --- /dev/null +++ b/L1Trigger/Phase2L1Taus/BuildFile.xml @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauBuilder.h b/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauBuilder.h new file mode 100644 index 0000000000000..14ee5ba8120dd --- /dev/null +++ b/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauBuilder.h @@ -0,0 +1,103 @@ +#ifndef L1Trigger_Phase2L1Taus_L1HPSPFTauBuilder_h +#define L1Trigger_Phase2L1Taus_L1HPSPFTauBuilder_h + +#include "FWCore/ParameterSet/interface/ParameterSet.h" // edm::ParameterSet +#include "DataFormats/Provenance/interface/ProductID.h" // edm::ProductID +#include "L1Trigger/Phase2L1Taus/interface/L1HPSPFTauQualityCut.h" // L1HPSPFTauQualityCut +#include "DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h" // l1t::L1HPSPFTau +#include "DataFormats/L1TParticleFlow/interface/PFCandidate.h" // l1t::PFCandidate, l1t::PFCandidateCollection, l1t::PFCandidateRef +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/L1TCorrelator/interface/TkPrimaryVertex.h" +#include "CommonTools/Utils/interface/FormulaEvaluator.h" +#include // TFormula +#include // TFile +#include // TH1 + +#include + +class L1HPSPFTauBuilder { +public: + L1HPSPFTauBuilder(const edm::ParameterSet& cfg); + ~L1HPSPFTauBuilder(); + + void reset(); + void setL1PFCandProductID(const edm::ProductID& l1PFCandProductID); + void setVertex(const l1t::TkPrimaryVertexRef& primaryVertex); + void setL1PFTauSeed(const l1t::PFCandidateRef& l1PFCandSeed); + //void setL1PFTauSeed(const reco::CaloJetRef& l1Jet_seed); + void setL1PFTauSeed(const reco::CaloJetRef& l1JetSeed, const std::vector& l1PFCands); + void addL1PFCandidates(const std::vector& l1PFCands); + void buildL1PFTau(); + + l1t::L1HPSPFTau getL1PFTau() const { return l1PFTau_; } + +private: + l1t::PFCandidateRefVector convertToRefVector(const std::vector& l1PFCands); + + bool isWithinSignalCone(const l1t::PFCandidate& l1PFCand); + bool isWithinStrip(const l1t::PFCandidate& l1PFCand); + bool isWithinIsolationCone(const l1t::PFCandidate& l1PFCand); + + std::unique_ptr signalConeSizeFormula_; + double signalConeSize_; + double signalConeSize2_; + double minSignalConeSize_; + double maxSignalConeSize_; + + bool useStrips_; + double stripSizeEta_; + double stripSizePhi_; + + double isolationConeSize_; + double isolationConeSize2_; + + std::vector signalQualityCutsDzCutDisabled_; + std::vector signalQualityCutsDzCutEnabledPrimary_; + std::vector isolationQualityCutsDzCutDisabled_; + std::vector isolationQualityCutsDzCutEnabledPrimary_; + std::vector isolationQualityCutsDzCutEnabledPileup_; + edm::ProductID l1PFCandProductID_; + bool isPFCandSeeded_; + l1t::PFCandidateRef l1PFCandSeed_; + bool isJetSeeded_; + reco::CaloJetRef l1JetSeed_; + double l1PFTauSeedEta_; + double l1PFTauSeedPhi_; + double l1PFTauSeedZVtx_; + double sumAllL1PFCandidatesPt_; + l1t::TkPrimaryVertexRef primaryVertex_; + l1t::L1HPSPFTau l1PFTau_; + + reco::Particle::LorentzVector stripP4_; + + std::vector signalAllL1PFCandidates_; + std::vector signalChargedHadrons_; + std::vector signalElectrons_; + std::vector signalNeutralHadrons_; + std::vector signalPhotons_; + std::vector signalMuons_; + + std::vector stripAllL1PFCandidates_; + std::vector stripElectrons_; + std::vector stripPhotons_; + + std::vector isoAllL1PFCandidates_; + std::vector isoChargedHadrons_; + std::vector isoElectrons_; + std::vector isoNeutralHadrons_; + std::vector isoPhotons_; + std::vector isoMuons_; + + std::vector sumAllL1PFCandidates_; + std::vector sumChargedHadrons_; + std::vector sumElectrons_; + std::vector sumNeutralHadrons_; + std::vector sumPhotons_; + std::vector sumMuons_; + + double sumChargedIsoPileup_; + + bool debug_; +}; + +#endif diff --git a/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauProducer.h b/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauProducer.h new file mode 100644 index 0000000000000..544f34bf86322 --- /dev/null +++ b/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauProducer.h @@ -0,0 +1,69 @@ +#ifndef L1Trigger_Phase2L1Taus_L1HPSPFTauProducer_h +#define L1Trigger_Phase2L1Taus_L1HPSPFTauProducer_h + +#include "FWCore/Framework/interface/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" + +#include "L1Trigger/Phase2L1Taus/interface/L1HPSPFTauQualityCut.h" // L1HPSPFTauQualityCut +#include "L1Trigger/Phase2L1Taus/interface/L1HPSPFTauBuilder.h" // L1HPSPFTauBuilder +#include "DataFormats/Phase2L1Taus/interface/L1HPSPFTau.h" // l1t::L1HPSPFTau +#include "DataFormats/Phase2L1Taus/interface/L1HPSPFTauFwd.h" // l1t::L1HPSPFTauCollection +#include "DataFormats/L1TParticleFlow/interface/PFCandidate.h" // l1t::PFCandidate, l1t::PFCandidateCollection, l1t::PFCandidateRef +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/L1TCorrelator/interface/TkPrimaryVertex.h" + +#include +#include + +class L1HPSPFTauProducer : public edm::stream::EDProducer<> { +public: + explicit L1HPSPFTauProducer(const edm::ParameterSet& cfg); + ~L1HPSPFTauProducer(); + +private: + void produce(edm::Event& evt, const edm::EventSetup& es); + + std::string moduleLabel_; + + std::unique_ptr tauBuilder_; + + edm::InputTag srcL1PFCands_; + edm::EDGetTokenT tokenL1PFCands_; + edm::InputTag srcL1Jets_; + edm::EDGetTokenT> tokenL1Jets_; + edm::InputTag srcL1Vertices_; + edm::EDGetTokenT> tokenL1Vertices_; + + std::vector signalQualityCutsDzCutDisabled_; + std::vector isolationQualityCutsDzCutDisabled_; + + bool useChargedPFCandSeeds_; + double minSeedChargedPFCandPt_; + double maxSeedChargedPFCandEta_; + double maxSeedChargedPFCandDz_; + + bool useJetSeeds_; + double minSeedJetPt_; + double maxSeedJetEta_; + + double minPFTauPt_; + double maxPFTauEta_; + double minLeadChargedPFCandPt_; + double maxLeadChargedPFCandEta_; + double maxLeadChargedPFCandDz_; + double maxChargedIso_; + double maxChargedRelIso_; + + double deltaRCleaning_; + double deltaR2Cleaning_; + + bool applyPreselection_; + + bool debug_; +}; + +#endif diff --git a/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauQualityCut.h b/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauQualityCut.h new file mode 100644 index 0000000000000..30db6ee2cbade --- /dev/null +++ b/L1Trigger/Phase2L1Taus/interface/L1HPSPFTauQualityCut.h @@ -0,0 +1,46 @@ +#ifndef L1Trigger_Phase2L1Taus_L1HPSPFTauQualityCut_h +#define L1Trigger_Phase2L1Taus_L1HPSPFTauQualityCut_h + +#include "FWCore/ParameterSet/interface/ParameterSet.h" // edm::ParameterSet +#include "DataFormats/L1TParticleFlow/interface/PFCandidate.h" // l1t::PFCandidate +#include // std::string +#include // std::vector + +class L1HPSPFTauQualityCut { +public: + /// constructor + L1HPSPFTauQualityCut(const edm::ParameterSet& cfg); + + /// destructor + ~L1HPSPFTauQualityCut(); + + /// returns true (false) if PFCandidate passes (fails) quality cuts + bool operator()(const l1t::PFCandidate& pfCand, float_t primaryVertexZ) const; + + /// accessor functions + l1t::PFCandidate::ParticleType pfCandType() const; + enum { kDisabled, kEnabledPrimary, kEnabledPileup }; + int dzCut() const; + float_t minPt() const; + float_t maxDz() const; + +private: + l1t::PFCandidate::ParticleType pfCandType_; + + int dzCut_; // flag to invert dz cut in order to compute charged isolation from pileup for delta-beta corrections + + float_t minPt_; + float_t maxDz_; + + bool debug_; +}; + +std::vector readL1PFTauQualityCuts(const edm::ParameterSet& cfg, + const std::string& dzCut, + bool debug = false); + +bool isSelected(const std::vector& qualityCuts, + const l1t::PFCandidate& pfCand, + float_t primaryVertexZ); + +#endif diff --git a/L1Trigger/Phase2L1Taus/plugins/BuildFile.xml b/L1Trigger/Phase2L1Taus/plugins/BuildFile.xml new file mode 100644 index 0000000000000..79bb738e84a18 --- /dev/null +++ b/L1Trigger/Phase2L1Taus/plugins/BuildFile.xml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/L1Trigger/Phase2L1Taus/plugins/L1HPSPFTauProducer.cc b/L1Trigger/Phase2L1Taus/plugins/L1HPSPFTauProducer.cc new file mode 100644 index 0000000000000..8e2168f9b8251 --- /dev/null +++ b/L1Trigger/Phase2L1Taus/plugins/L1HPSPFTauProducer.cc @@ -0,0 +1,217 @@ +#include "L1Trigger/Phase2L1Taus/interface/L1HPSPFTauProducer.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include // std::fabs + +L1HPSPFTauProducer::L1HPSPFTauProducer(const edm::ParameterSet& cfg) + : moduleLabel_(cfg.getParameter("@module_label")), + tauBuilder_(nullptr), + useChargedPFCandSeeds_(cfg.getParameter("useChargedPFCandSeeds")), + minSeedChargedPFCandPt_(cfg.getParameter("minSeedChargedPFCandPt")), + maxSeedChargedPFCandEta_(cfg.getParameter("maxSeedChargedPFCandEta")), + maxSeedChargedPFCandDz_(cfg.getParameter("maxSeedChargedPFCandDz")), + useJetSeeds_(cfg.getParameter("useJetSeeds")), + minSeedJetPt_(cfg.getParameter("minSeedJetPt")), + maxSeedJetEta_(cfg.getParameter("maxSeedJetEta")), + minPFTauPt_(cfg.getParameter("minPFTauPt")), + maxPFTauEta_(cfg.getParameter("maxPFTauEta")), + minLeadChargedPFCandPt_(cfg.getParameter("minLeadChargedPFCandPt")), + maxLeadChargedPFCandEta_(cfg.getParameter("maxLeadChargedPFCandEta")), + maxLeadChargedPFCandDz_(cfg.getParameter("maxLeadChargedPFCandDz")), + maxChargedIso_(cfg.getParameter("maxChargedIso")), + maxChargedRelIso_(cfg.getParameter("maxChargedRelIso")), + deltaRCleaning_(cfg.getParameter("deltaRCleaning")), + applyPreselection_(cfg.getParameter("applyPreselection")), + debug_(cfg.getUntrackedParameter("debug", false)) { + if (debug_) { + std::cout << ":" << std::endl; + } + + tauBuilder_.reset(new L1HPSPFTauBuilder(cfg)); + + srcL1PFCands_ = cfg.getParameter("srcL1PFCands"); + tokenL1PFCands_ = consumes(srcL1PFCands_); + srcL1Jets_ = cfg.getParameter("srcL1Jets"); + if (useJetSeeds_) { + tokenL1Jets_ = consumes>(srcL1Jets_); + } + srcL1Vertices_ = cfg.getParameter("srcL1Vertices"); + if (srcL1Vertices_.label() != "") { + tokenL1Vertices_ = consumes>(srcL1Vertices_); + } + deltaR2Cleaning_ = deltaRCleaning_ * deltaRCleaning_; + + edm::ParameterSet cfg_signalQualityCuts = cfg.getParameter("signalQualityCuts"); + signalQualityCutsDzCutDisabled_ = readL1PFTauQualityCuts(cfg_signalQualityCuts, "disabled"); + edm::ParameterSet cfg_isolationQualityCuts = cfg.getParameter("isolationQualityCuts"); + isolationQualityCutsDzCutDisabled_ = readL1PFTauQualityCuts(cfg_isolationQualityCuts, "disabled"); + + produces(); +} + +L1HPSPFTauProducer::~L1HPSPFTauProducer() {} + +namespace { + bool isHigherPt_pfCandRef(const l1t::PFCandidateRef& l1PFCand1, const l1t::PFCandidateRef& l1PFCand2) { + return l1PFCand1->pt() > l1PFCand2->pt(); + } + + bool isHigherPt_pfTau(const l1t::L1HPSPFTau& l1PFTau1, const l1t::L1HPSPFTau& l1PFTau2) { + return l1PFTau1.pt() > l1PFTau2.pt(); + } +} // namespace + +void L1HPSPFTauProducer::produce(edm::Event& evt, const edm::EventSetup& es) { + std::unique_ptr l1PFTauCollectionCleaned(new l1t::L1HPSPFTauCollection()); + + edm::Handle l1PFCands; + evt.getByToken(tokenL1PFCands_, l1PFCands); + + l1t::TkPrimaryVertexRef primaryVertex; + float primaryVertex_z = 0.; + if (srcL1Vertices_.label() != "") { + edm::Handle> vertices; + evt.getByToken(tokenL1Vertices_, vertices); + if (vertices->size() > 0) { + primaryVertex = l1t::TkPrimaryVertexRef(vertices, 0); + primaryVertex_z = primaryVertex->zvertex(); + } + } + + if (debug_) { + std::cout << "BEFORE selection:" << std::endl; + for (auto l1PFCand : *l1PFCands) { + printPFCand(std::cout, l1PFCand, primaryVertex_z); + } + } + + // build collection of selected PFCandidates + std::vector selectedL1PFCandsSignalQualityCuts; + std::vector selectedL1PFCandsSignalOrIsolationQualityCuts; + size_t numL1PFCands = l1PFCands->size(); + for (size_t idxL1PFCand = 0; idxL1PFCand < numL1PFCands; ++idxL1PFCand) { + l1t::PFCandidateRef l1PFCand(l1PFCands, idxL1PFCand); + bool passesSignalQualityCuts = isSelected(signalQualityCutsDzCutDisabled_, *l1PFCand, primaryVertex_z); + bool passesIsolationQualityCuts = isSelected(isolationQualityCutsDzCutDisabled_, *l1PFCand, primaryVertex_z); + if (passesSignalQualityCuts) { + selectedL1PFCandsSignalQualityCuts.push_back(l1PFCand); + } + if (passesSignalQualityCuts || passesIsolationQualityCuts) { + selectedL1PFCandsSignalOrIsolationQualityCuts.push_back(l1PFCand); + } + } + + // sort PFCandidate collection by decreasing pT + std::sort(selectedL1PFCandsSignalQualityCuts.begin(), selectedL1PFCandsSignalQualityCuts.end(), isHigherPt_pfCandRef); + std::sort(selectedL1PFCandsSignalOrIsolationQualityCuts.begin(), + selectedL1PFCandsSignalOrIsolationQualityCuts.end(), + isHigherPt_pfCandRef); + + if (debug_) { + std::cout << "AFTER selection (signalQualityCuts):" << std::endl; + for (auto l1PFCand : selectedL1PFCandsSignalQualityCuts) { + printPFCand(std::cout, *l1PFCand, primaryVertex_z); + } + } + + l1t::L1HPSPFTauCollection l1PFTauCollectionUncleaned; + + if (useChargedPFCandSeeds_) { + for (auto l1PFCand : selectedL1PFCandsSignalQualityCuts) { + if (l1PFCand->charge() != 0 && l1PFCand->pt() > minSeedChargedPFCandPt_ && + std::fabs(l1PFCand->eta()) < maxSeedChargedPFCandEta_) { + bool isFromPrimaryVertex = false; + if (primaryVertex.get()) { + l1t::PFTrackRef l1PFTrack = l1PFCand->pfTrack(); + double dz = std::fabs(l1PFTrack->vertex().z() - primaryVertex_z); + if (dz < maxSeedChargedPFCandDz_) { + isFromPrimaryVertex = true; + } + } else { + isFromPrimaryVertex = true; + } + if (isFromPrimaryVertex) { + tauBuilder_->reset(); + tauBuilder_->setL1PFCandProductID(l1PFCands.id()); + tauBuilder_->setVertex(primaryVertex); + tauBuilder_->setL1PFTauSeed(l1PFCand); + tauBuilder_->addL1PFCandidates(selectedL1PFCandsSignalOrIsolationQualityCuts); + tauBuilder_->buildL1PFTau(); + l1t::L1HPSPFTau l1PFTau = tauBuilder_->getL1PFTau(); + if (l1PFTau.pt() > 1.) + l1PFTauCollectionUncleaned.push_back(l1PFTau); + } + } + } + } + + if (useJetSeeds_) { + edm::Handle> l1Jets; + evt.getByToken(tokenL1Jets_, l1Jets); + + size_t numL1Jets = l1Jets->size(); + for (size_t idxL1Jet = 0; idxL1Jet < numL1Jets; ++idxL1Jet) { + reco::CaloJetRef l1Jet(l1Jets, idxL1Jet); + if (l1Jet->pt() > minSeedJetPt_ && std::fabs(l1Jet->eta()) < maxSeedJetEta_) { + tauBuilder_->reset(); + tauBuilder_->setL1PFCandProductID(l1PFCands.id()); + tauBuilder_->setVertex(primaryVertex); + //tauBuilder_->setL1PFTauSeed(l1Jet); + tauBuilder_->setL1PFTauSeed(l1Jet, selectedL1PFCandsSignalQualityCuts); + tauBuilder_->addL1PFCandidates(selectedL1PFCandsSignalOrIsolationQualityCuts); + tauBuilder_->buildL1PFTau(); + l1t::L1HPSPFTau l1PFTau = tauBuilder_->getL1PFTau(); + if (l1PFTau.pt() > 1.) + l1PFTauCollectionUncleaned.push_back(l1PFTau); + } + } + } + + // sort PFTau candidate collection by decreasing pT + std::sort(l1PFTauCollectionUncleaned.begin(), l1PFTauCollectionUncleaned.end(), isHigherPt_pfTau); + + if (debug_) { + std::cout << "BEFORE cleaning:" << std::endl; + for (size_t idx = 0; idx < l1PFTauCollectionUncleaned.size(); ++idx) { + const l1t::L1HPSPFTau& l1PFTau = l1PFTauCollectionUncleaned.at(idx); + std::cout << "L1HPSPFTau #" << idx << ": " << l1PFTau; + } + } + + for (auto l1PFTau : l1PFTauCollectionUncleaned) { + if (applyPreselection_ && + !(l1PFTau.pt() > minPFTauPt_ && std::fabs(l1PFTau.eta()) < maxPFTauEta_ && + l1PFTau.leadChargedPFCand().isNonnull() && l1PFTau.leadChargedPFCand()->pt() > minLeadChargedPFCandPt_ && + std::fabs(l1PFTau.leadChargedPFCand()->eta()) < maxLeadChargedPFCandEta_ && + (srcL1Vertices_.label() == "" || + (primaryVertex.isNonnull() && l1PFTau.leadChargedPFCand()->pfTrack().isNonnull() && + std::fabs(l1PFTau.leadChargedPFCand()->pfTrack()->vertex().z() - primaryVertex->zvertex()) < + maxLeadChargedPFCandDz_)) && + l1PFTau.sumChargedIso() < maxChargedIso_ && l1PFTau.sumChargedIso() < maxChargedRelIso_ * l1PFTau.pt())) + continue; + + bool isOverlap = false; + for (auto l1PFTau2 : *l1PFTauCollectionCleaned) { + double deltaEta = l1PFTau.eta() - l1PFTau2.eta(); + double deltaPhi = l1PFTau.phi() - l1PFTau2.phi(); + if ((deltaEta * deltaEta + deltaPhi * deltaPhi) < deltaR2Cleaning_) { + isOverlap = true; + } + } + if (!isOverlap) { + l1PFTauCollectionCleaned->push_back(l1PFTau); + } + } + + if (debug_) { + std::cout << "AFTER cleaning:" << std::endl; + for (size_t idx = 0; idx < l1PFTauCollectionCleaned->size(); ++idx) { + const l1t::L1HPSPFTau& l1PFTau = l1PFTauCollectionCleaned->at(idx); + std::cout << "L1HPSPFTau #" << idx << ": " << l1PFTau; + } + } + + evt.put(std::move(l1PFTauCollectionCleaned)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(L1HPSPFTauProducer); diff --git a/L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPF_cfi.py b/L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPF_cfi.py new file mode 100644 index 0000000000000..b821eae0dadd3 --- /dev/null +++ b/L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPF_cfi.py @@ -0,0 +1,71 @@ +import FWCore.ParameterSet.Config as cms + +L1HPSPFTauProducerPF = cms.EDProducer("L1HPSPFTauProducer", + srcL1PFCands = cms.InputTag("l1pfCandidates:PF"), + srcL1Jets = cms.InputTag("Phase1L1TJetProducer:UncalibratedPhase1L1TJetFromPfCandidates"), + srcL1Vertices = cms.InputTag("L1TkPrimaryVertex"), + useChargedPFCandSeeds = cms.bool(True), + minSeedChargedPFCandPt = cms.double(5.), + maxSeedChargedPFCandEta = cms.double(2.4), + maxSeedChargedPFCandDz = cms.double(1.e+3), + useJetSeeds = cms.bool(True), + minSeedJetPt = cms.double(30.), + maxSeedJetEta = cms.double(2.4), + signalConeSize = cms.string("2.8/max(1., pt)"), + minSignalConeSize = cms.double(0.05), + maxSignalConeSize = cms.double(0.10), + useStrips = cms.bool(True), + stripSizeEta = cms.double(0.05), + stripSizePhi = cms.double(0.20), + isolationConeSize = cms.double(0.4), + minPFTauPt = cms.double(20.), + maxPFTauEta = cms.double(2.4), + minLeadChargedPFCandPt = cms.double(1.), + maxLeadChargedPFCandEta = cms.double(2.4), + maxLeadChargedPFCandDz = cms.double(1.e+3), + maxChargedIso = cms.double(1.e+3), + maxChargedRelIso = cms.double(1.0), + deltaRCleaning = cms.double(0.4), + signalQualityCuts = cms.PSet( + chargedHadron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(0.4), + ), + neutralHadron = cms.PSet( + minPt = cms.double(0.) + ), + muon = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(0.4), + ), + electron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(0.4), + ), + photon = cms.PSet( + minPt = cms.double(0.) + ) + ), + isolationQualityCuts = cms.PSet( + chargedHadron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(0.4), + ), + neutralHadron = cms.PSet( + minPt = cms.double(0.) + ), + muon = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(0.4), + ), + electron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(0.4), + ), + photon = cms.PSet( + minPt = cms.double(0.) + ) + ), + applyPreselection = cms.bool(False), + debug = cms.untracked.bool(False) +) diff --git a/L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPuppi_cfi.py b/L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPuppi_cfi.py new file mode 100644 index 0000000000000..6a49ea3377e98 --- /dev/null +++ b/L1Trigger/Phase2L1Taus/python/L1HPSPFTauProducerPuppi_cfi.py @@ -0,0 +1,71 @@ +import FWCore.ParameterSet.Config as cms + +L1HPSPFTauProducerPuppi = cms.EDProducer("L1HPSPFTauProducer", + srcL1PFCands = cms.InputTag("l1pfCandidates:Puppi"), + srcL1Jets = cms.InputTag("Phase1L1TJetProducer:UncalibratedPhase1L1TJetFromPfCandidates"), + srcL1Vertices = cms.InputTag("L1TkPrimaryVertex"), + useChargedPFCandSeeds = cms.bool(True), + minSeedChargedPFCandPt = cms.double(5.), + maxSeedChargedPFCandEta = cms.double(2.4), + maxSeedChargedPFCandDz = cms.double(1.e+3), + useJetSeeds = cms.bool(True), + minSeedJetPt = cms.double(30.), + maxSeedJetEta = cms.double(2.4), + signalConeSize = cms.string("2.8/max(1., pt)"), + minSignalConeSize = cms.double(0.05), + maxSignalConeSize = cms.double(0.10), + useStrips = cms.bool(True), + stripSizeEta = cms.double(0.05), + stripSizePhi = cms.double(0.20), + isolationConeSize = cms.double(0.4), + minPFTauPt = cms.double(20.), + maxPFTauEta = cms.double(2.4), + minLeadChargedPFCandPt = cms.double(1.), + maxLeadChargedPFCandEta = cms.double(2.4), + maxLeadChargedPFCandDz = cms.double(1.e+3), + maxChargedIso = cms.double(1.e+3), + maxChargedRelIso = cms.double(1.0), + deltaRCleaning = cms.double(0.4), + signalQualityCuts = cms.PSet( + chargedHadron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(1.e+3), + ), + neutralHadron = cms.PSet( + minPt = cms.double(0.) + ), + muon = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(1.e+3), + ), + electron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(1.e+3), + ), + photon = cms.PSet( + minPt = cms.double(0.) + ) + ), + isolationQualityCuts = cms.PSet( + chargedHadron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(1.e+3), + ), + neutralHadron = cms.PSet( + minPt = cms.double(0.) + ), + muon = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(1.e+3), + ), + electron = cms.PSet( + minPt = cms.double(0.), + maxDz = cms.double(1.e+3), + ), + photon = cms.PSet( + minPt = cms.double(0.) + ) + ), + applyPreselection = cms.bool(False), + debug = cms.untracked.bool(False) +) diff --git a/L1Trigger/Phase2L1Taus/python/l1emulator_cff.py b/L1Trigger/Phase2L1Taus/python/l1emulator_cff.py new file mode 100644 index 0000000000000..f79f1cf2e177e --- /dev/null +++ b/L1Trigger/Phase2L1Taus/python/l1emulator_cff.py @@ -0,0 +1,47 @@ +import FWCore.ParameterSet.Config as cms + +l1emulator = cms.Sequence() + +from SimCalorimetry.HcalTrigPrimProducers.hcaltpdigi_cff import * +from CalibCalorimetry.CaloTPG.CaloTPGTranscoder_cfi import * + +from L1Trigger.L1THGCal.hgcalTriggerPrimitives_cff import * +l1emulator += hgcalTriggerPrimitives + +from SimCalorimetry.EcalEBTrigPrimProducers.ecalEBTriggerPrimitiveDigis_cff import * +l1emulator += simEcalEBTriggerPrimitiveDigis + +from L1Trigger.TrackFindingTracklet.Tracklet_cfi import * +L1TRK_NAME = "TTTracksFromTrackletEmulation" +L1TRK_LABEL = "Level1TTTracks" + +from RecoVertex.BeamSpotProducer.BeamSpot_cfi import * +l1emulator += offlineBeamSpot + +l1emulator += TTTracksFromTrackletEmulation + +from SimTracker.TrackTriggerAssociation.TrackTriggerAssociator_cff import * +TTTrackAssociatorFromPixelDigis.TTTracks = cms.VInputTag( cms.InputTag(L1TRK_NAME, L1TRK_LABEL) ) +l1emulator += TrackTriggerAssociatorTracks + +from L1Trigger.L1TTrackMatch.L1TkPrimaryVertexProducer_cfi import * +l1emulator += L1TkPrimaryVertex + +from Configuration.StandardSequences.SimL1Emulator_cff import * +l1emulator += SimL1Emulator + +from L1Trigger.Phase2L1ParticleFlow.pfTracksFromL1Tracks_cfi import * +l1emulator += pfTracksFromL1Tracks + +from L1Trigger.Phase2L1ParticleFlow.l1ParticleFlow_cff import * +l1emulator += l1ParticleFlow + +from L1Trigger.L1CaloTrigger.Phase1L1TJets_cff import * +l1emulator += Phase1L1TJetsSequence + + + + + + + diff --git a/L1Trigger/Phase2L1Taus/src/L1HPSPFTauBuilder.cc b/L1Trigger/Phase2L1Taus/src/L1HPSPFTauBuilder.cc new file mode 100644 index 0000000000000..7b20f637b8a1c --- /dev/null +++ b/L1Trigger/Phase2L1Taus/src/L1HPSPFTauBuilder.cc @@ -0,0 +1,446 @@ +#include "L1Trigger/Phase2L1Taus/interface/L1HPSPFTauBuilder.h" +#include "FWCore/Utilities/interface/Exception.h" // cms::Exception +#include "DataFormats/Math/interface/deltaR.h" // reco::deltaR +#include // TString, Form() +#include // TMath::Pi() +#include // std::string +#include // std::max(), std::sort() +#include // std::fabs + +L1HPSPFTauBuilder::L1HPSPFTauBuilder(const edm::ParameterSet& cfg) + : signalConeSizeFormula_(nullptr), + minSignalConeSize_(cfg.getParameter("minSignalConeSize")), + maxSignalConeSize_(cfg.getParameter("maxSignalConeSize")), + useStrips_(cfg.getParameter("useStrips")), + stripSizeEta_(cfg.getParameter("stripSizeEta")), + stripSizePhi_(cfg.getParameter("stripSizePhi")), + isolationConeSize_(cfg.getParameter("isolationConeSize")), + debug_(cfg.getUntrackedParameter("debug", false)) { + std::string signalConeSizeFormulaOriginal = cfg.getParameter("signalConeSize"); + TString signalConeSizeFormulaModified = signalConeSizeFormulaOriginal.data(); + signalConeSizeFormulaModified.ReplaceAll("pt", "x"); + signalConeSizeFormula_ = std::make_unique(signalConeSizeFormulaModified.Data()); + if (!signalConeSizeFormula_) { + throw cms::Exception("L1HPSPFTauBuilder") + << "Invalid Configuration parameter 'signalConeSize' = '" << signalConeSizeFormulaOriginal << "' !!\n"; + } + assert(maxSignalConeSize_ >= minSignalConeSize_); + + isolationConeSize2_ = isolationConeSize_ * isolationConeSize_; + + if (debug_) { + std::cout << "setting Quality cuts for signal PFCands:" << std::endl; + } + edm::ParameterSet cfg_signalQualityCuts = cfg.getParameter("signalQualityCuts"); + signalQualityCutsDzCutDisabled_ = readL1PFTauQualityCuts(cfg_signalQualityCuts, "disabled", debug_); + signalQualityCutsDzCutEnabledPrimary_ = readL1PFTauQualityCuts(cfg_signalQualityCuts, "enabled_primary", debug_); + if (debug_) { + std::cout << "setting Quality cuts for isolation PFCands:" << std::endl; + } + edm::ParameterSet cfg_isolationQualityCuts = cfg.getParameter("isolationQualityCuts"); + isolationQualityCutsDzCutDisabled_ = readL1PFTauQualityCuts(cfg_isolationQualityCuts, "disabled", debug_); + isolationQualityCutsDzCutEnabledPrimary_ = + readL1PFTauQualityCuts(cfg_isolationQualityCuts, "enabled_primary", debug_); + isolationQualityCutsDzCutEnabledPileup_ = readL1PFTauQualityCuts(cfg_isolationQualityCuts, "enabled_pileup", debug_); +} + +L1HPSPFTauBuilder::~L1HPSPFTauBuilder() {} + +void L1HPSPFTauBuilder::reset() { + signalConeSize_ = 0.; + signalConeSize2_ = 0.; + + l1PFCandProductID_ = edm::ProductID(); + isPFCandSeeded_ = false; + l1PFCandSeed_ = l1t::PFCandidateRef(); + isJetSeeded_ = false; + l1JetSeed_ = reco::CaloJetRef(); + l1PFTauSeedEta_ = 0.; + l1PFTauSeedPhi_ = 0.; + l1PFTauSeedZVtx_ = 0.; + sumAllL1PFCandidatesPt_ = 0.; + primaryVertex_ = l1t::TkPrimaryVertexRef(); + l1PFTau_ = l1t::L1HPSPFTau(); + + stripP4_ = reco::Particle::LorentzVector(0., 0., 0., 0.); + + signalAllL1PFCandidates_.clear(); + signalChargedHadrons_.clear(); + signalElectrons_.clear(); + signalNeutralHadrons_.clear(); + signalPhotons_.clear(); + signalMuons_.clear(); + + stripAllL1PFCandidates_.clear(); + stripElectrons_.clear(); + stripPhotons_.clear(); + + isoAllL1PFCandidates_.clear(); + isoChargedHadrons_.clear(); + isoElectrons_.clear(); + isoNeutralHadrons_.clear(); + isoPhotons_.clear(); + isoMuons_.clear(); + + sumAllL1PFCandidates_.clear(); + sumChargedHadrons_.clear(); + sumElectrons_.clear(); + sumNeutralHadrons_.clear(); + sumPhotons_.clear(); + sumMuons_.clear(); + + sumChargedIsoPileup_ = 0.; +} + +void L1HPSPFTauBuilder::setL1PFCandProductID(const edm::ProductID& l1PFCandProductID) { + l1PFCandProductID_ = l1PFCandProductID; +} + +void L1HPSPFTauBuilder::setVertex(const l1t::TkPrimaryVertexRef& primaryVertex) { primaryVertex_ = primaryVertex; } + +void L1HPSPFTauBuilder::setL1PFTauSeed(const l1t::PFCandidateRef& l1PFCandSeed) { + if (debug_) { + std::cout << ":" << std::endl; + std::cout << "seeding L1HPSPFTau with ChargedPFCand:"; + printPFCand(std::cout, *l1PFCandSeed, primaryVertex_); + } + + l1PFCandSeed_ = l1PFCandSeed; + l1PFTauSeedEta_ = l1PFCandSeed->eta(); + l1PFTauSeedPhi_ = l1PFCandSeed->phi(); + if (l1PFCandSeed->charge() != 0 && l1PFCandSeed->pfTrack().isNonnull()) { + l1PFTauSeedZVtx_ = l1PFCandSeed->pfTrack()->vertex().z(); + isPFCandSeeded_ = true; + } +} +// This is commented as l1JetSeed->numberOfDaughters() = 0 +// Alternative way is used below for the moment +/* +void L1HPSPFTauBuilder::setL1PFTauSeed(const reco::CaloJetRef& l1JetSeed) { + if (debug_) { + std::cout << ":" << std::endl; + std::cout << "seeding L1HPSPFTau with Jet:"; + std::cout << " pT = " << l1JetSeed->pt() << ", eta = " << l1JetSeed->eta() << ", phi = " << l1JetSeed->phi() + << std::endl; + } + + l1JetSeed_ = l1JetSeed; + reco::Candidate::LorentzVector l1PFTauSeed_p4; + float l1PFTauSeedZVtx = 0.; + bool l1PFTauSeed_hasVtx = false; + float max_chargedPFCand_pt = -1.; + size_t numConstituents = l1JetSeed->numberOfDaughters(); + for (size_t idxConstituent = 0; idxConstituent < numConstituents; ++idxConstituent) { + const l1t::PFCandidate* l1PFCand = dynamic_cast(l1JetSeed->daughter(idxConstituent)); + if (!l1PFCand) { + throw cms::Exception("L1HPSPFTauBuilder") << "Jet was not built from l1t::PFCandidates !!\n"; + } + if (l1PFCand->id() == l1t::PFCandidate::ChargedHadron || l1PFCand->id() == l1t::PFCandidate::Electron || + l1PFCand->id() == l1t::PFCandidate::Photon || l1PFCand->id() == l1t::PFCandidate::Muon) { + l1PFTauSeed_p4 += l1PFCand->p4(); + if (l1PFCand->charge() != 0 && l1PFCand->pfTrack().isNonnull() && l1PFCand->pt() > max_chargedPFCand_pt) { + l1PFTauSeedZVtx = l1PFCand->pfTrack()->vertex().z(); + l1PFTauSeed_hasVtx = true; + max_chargedPFCand_pt = l1PFCand->pt(); + } + } + } + if (l1PFTauSeed_p4.pt() > 1. && l1PFTauSeed_hasVtx) { + l1PFTauSeedEta_ = l1PFTauSeed_p4.eta(); + l1PFTauSeedPhi_ = l1PFTauSeed_p4.phi(); + l1PFTauSeedZVtx_ = l1PFTauSeedZVtx; + isJetSeeded_ = true; + } +} +*/ +void L1HPSPFTauBuilder::setL1PFTauSeed(const reco::CaloJetRef& l1JetSeed, + const std::vector& l1PFCands) { + if (debug_) { + std::cout << ":" << std::endl; + std::cout << "seeding L1HPSPFTau with Jet:"; + std::cout << " pT = " << l1JetSeed->pt() << ", eta = " << l1JetSeed->eta() << ", phi = " << l1JetSeed->phi() + << std::endl; + } + + l1JetSeed_ = l1JetSeed; + reco::Candidate::LorentzVector l1PFTauSeed_p4; + float l1PFTauSeedZVtx = 0.; + bool l1PFTauSeed_hasVtx = false; + float max_chargedPFCand_pt = -1.; + for (auto l1PFCand : l1PFCands) { + double dR = reco::deltaR(l1PFCand->eta(), l1PFCand->phi(), l1JetSeed->eta(), l1JetSeed->phi()); + if (dR > 0.4) + continue; + if (l1PFCand->id() == l1t::PFCandidate::ChargedHadron || l1PFCand->id() == l1t::PFCandidate::Electron || + l1PFCand->id() == l1t::PFCandidate::Photon || l1PFCand->id() == l1t::PFCandidate::Muon) { + l1PFTauSeed_p4 += l1PFCand->p4(); + if (l1PFCand->charge() != 0 && l1PFCand->pfTrack().isNonnull() && l1PFCand->pt() > max_chargedPFCand_pt) { + l1PFTauSeedZVtx = l1PFCand->pfTrack()->vertex().z(); + l1PFTauSeed_hasVtx = true; + max_chargedPFCand_pt = l1PFCand->pt(); + } + } + } + if (l1PFTauSeed_p4.pt() > 1. && l1PFTauSeed_hasVtx) { + l1PFTauSeedEta_ = l1PFTauSeed_p4.eta(); + l1PFTauSeedPhi_ = l1PFTauSeed_p4.phi(); + l1PFTauSeedZVtx_ = l1PFTauSeedZVtx; + isJetSeeded_ = true; + } +} + +void L1HPSPFTauBuilder::addL1PFCandidates(const std::vector& l1PFCands) { + if (debug_) { + std::cout << ":" << std::endl; + } + + // do not build tau candidates for which no reference z-position exists, + // as in this case charged PFCands originating from the primary (hard-scatter) interaction + // cannot be distinguished from charged PFCands originating from pileup + if (!(isPFCandSeeded_ || isJetSeeded_)) + return; + + for (auto l1PFCand : l1PFCands) { + if (!isWithinIsolationCone(*l1PFCand)) + continue; + sumAllL1PFCandidates_.push_back(l1PFCand); + if (l1PFCand->id() == l1t::PFCandidate::ChargedHadron) { + sumChargedHadrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Electron) { + sumElectrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::NeutralHadron) { + sumNeutralHadrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Photon) { + sumPhotons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Muon) { + sumMuons_.push_back(l1PFCand); + } + } + + for (auto l1PFCand : sumAllL1PFCandidates_) { + sumAllL1PFCandidatesPt_ += l1PFCand->pt(); + } + std::vector emptyV; + std::vector sumAllL1PFCandidatesPt(1); + sumAllL1PFCandidatesPt[0] = sumAllL1PFCandidatesPt_; + + signalConeSize_ = signalConeSizeFormula_->evaluate(sumAllL1PFCandidatesPt, emptyV); + + if (signalConeSize_ < minSignalConeSize_) + signalConeSize_ = minSignalConeSize_; + if (signalConeSize_ > maxSignalConeSize_) + signalConeSize_ = maxSignalConeSize_; + signalConeSize2_ = signalConeSize_ * signalConeSize_; + + for (auto l1PFCand : sumAllL1PFCandidates_) { + if (debug_) { + printPFCand(std::cout, *l1PFCand, primaryVertex_); + } + + bool isSignalPFCand = false; + bool isStripPFCand = false; + bool isElectron_or_Photon = + l1PFCand->id() == l1t::PFCandidate::Electron || l1PFCand->id() == l1t::PFCandidate::Photon; + bool isChargedHadron = l1PFCand->id() == l1t::PFCandidate::ChargedHadron; + if (isWithinSignalCone(*l1PFCand) && !(isChargedHadron && signalChargedHadrons_.size() > 3)) { + isSignalPFCand = true; + } + if (isElectron_or_Photon && isWithinStrip(*l1PFCand)) { + if (useStrips_) { + isSignalPFCand = true; + } + isStripPFCand = true; + } + bool passesSignalQualityCuts = isSelected(signalQualityCutsDzCutEnabledPrimary_, *l1PFCand, l1PFTauSeedZVtx_); + if (isSignalPFCand && passesSignalQualityCuts) { + signalAllL1PFCandidates_.push_back(l1PFCand); + if (l1PFCand->id() == l1t::PFCandidate::ChargedHadron) { + signalChargedHadrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Electron) { + signalElectrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::NeutralHadron) { + signalNeutralHadrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Photon) { + signalPhotons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Muon) { + signalMuons_.push_back(l1PFCand); + } + } + if (isStripPFCand && passesSignalQualityCuts) { + stripAllL1PFCandidates_.push_back(l1PFCand); + if (l1PFCand->id() == l1t::PFCandidate::Electron) { + stripElectrons_.push_back(l1PFCand); + stripP4_ += l1PFCand->p4(); + } else if (l1PFCand->id() == l1t::PFCandidate::Photon) { + stripPhotons_.push_back(l1PFCand); + stripP4_ += l1PFCand->p4(); + } else + assert(0); + } + + bool isIsolationPFCand = isWithinIsolationCone(*l1PFCand) && !isSignalPFCand; + bool passesIsolationQualityCuts = isSelected(isolationQualityCutsDzCutEnabledPrimary_, *l1PFCand, l1PFTauSeedZVtx_); + if (isIsolationPFCand && passesIsolationQualityCuts) { + isoAllL1PFCandidates_.push_back(l1PFCand); + if (l1PFCand->id() == l1t::PFCandidate::ChargedHadron) { + isoChargedHadrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Electron) { + isoElectrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::NeutralHadron) { + isoNeutralHadrons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Photon) { + isoPhotons_.push_back(l1PFCand); + } else if (l1PFCand->id() == l1t::PFCandidate::Muon) { + isoMuons_.push_back(l1PFCand); + } + } + + if (debug_) { + std::cout << "dR = " << reco::deltaR(l1PFCand->eta(), l1PFCand->phi(), l1PFTauSeedEta_, l1PFTauSeedPhi_) << ":" + << " isSignalPFCand = " << isSignalPFCand << ", isStripPFCand = " << isStripPFCand + << " (passesSignalQualityCuts = " << passesSignalQualityCuts << ")," + << " isIsolationPFCand = " << isIsolationPFCand + << " (passesIsolationQualityCuts = " << passesIsolationQualityCuts << ")" << std::endl; + } + } + + for (auto l1PFCand : l1PFCands) { + if (!isWithinIsolationCone(*l1PFCand)) + continue; + + if (l1PFCand->charge() != 0 && isSelected(isolationQualityCutsDzCutEnabledPileup_, *l1PFCand, l1PFTauSeedZVtx_)) { + sumChargedIsoPileup_ += l1PFCand->pt(); + } + } +} + +//void L1HPSPFTauBuilder::setRho(double rho) { rho_ = rho; } + +bool L1HPSPFTauBuilder::isWithinSignalCone(const l1t::PFCandidate& l1PFCand) { + if (isPFCandSeeded_ || isJetSeeded_) { + double deltaEta = l1PFCand.eta() - l1PFTauSeedEta_; + double deltaPhi = l1PFCand.phi() - l1PFTauSeedPhi_; + if ((deltaEta * deltaEta + deltaPhi * deltaPhi) < signalConeSize2_) + return true; + } + return false; +} + +bool L1HPSPFTauBuilder::isWithinStrip(const l1t::PFCandidate& l1PFCand) { + if (isPFCandSeeded_ || isJetSeeded_) { + double deltaEta = l1PFCand.eta() - l1PFTauSeedEta_; + double deltaPhi = l1PFCand.phi() - l1PFTauSeedPhi_; + if (std::fabs(deltaEta) < stripSizeEta_ && std::fabs(deltaPhi) < stripSizePhi_) + return true; + } + return false; +} + +bool L1HPSPFTauBuilder::isWithinIsolationCone(const l1t::PFCandidate& l1PFCand) { + double deltaEta = l1PFCand.eta() - l1PFTauSeedEta_; + double deltaPhi = l1PFCand.phi() - l1PFTauSeedPhi_; + if ((deltaEta * deltaEta + deltaPhi * deltaPhi) < isolationConeSize2_) + return true; + else + return false; +} + +void L1HPSPFTauBuilder::buildL1PFTau() { + reco::Particle::LorentzVector l1PFTau_p4; + for (auto l1PFCand : signalAllL1PFCandidates_) { + if (l1PFCand->id() == l1t::PFCandidate::ChargedHadron || l1PFCand->id() == l1t::PFCandidate::Electron || + l1PFCand->id() == l1t::PFCandidate::Photon) { + l1PFTau_p4 += l1PFCand->p4(); + if (l1PFCand->charge() != 0 && + (l1PFTau_.leadChargedPFCand().isNull() || l1PFCand->pt() > l1PFTau_.leadChargedPFCand()->pt())) { + l1PFTau_.setLeadChargedPFCand(l1PFCand); + } + } + } + l1PFTau_.setP4(l1PFTau_p4); + + l1PFTau_.setSeedChargedPFCand(l1PFCandSeed_); + l1PFTau_.setSeedJet(l1JetSeed_); + + l1PFTau_.setSignalAllL1PFCandidates(convertToRefVector(signalAllL1PFCandidates_)); + l1PFTau_.setSignalChargedHadrons(convertToRefVector(signalChargedHadrons_)); + l1PFTau_.setSignalElectrons(convertToRefVector(signalElectrons_)); + l1PFTau_.setSignalNeutralHadrons(convertToRefVector(signalNeutralHadrons_)); + l1PFTau_.setSignalPhotons(convertToRefVector(signalPhotons_)); + l1PFTau_.setSignalMuons(convertToRefVector(signalMuons_)); + + l1PFTau_.setStripAllL1PFCandidates(convertToRefVector(stripAllL1PFCandidates_)); + l1PFTau_.setStripElectrons(convertToRefVector(stripElectrons_)); + l1PFTau_.setStripPhotons(convertToRefVector(stripPhotons_)); + + l1PFTau_.setIsoAllL1PFCandidates(convertToRefVector(isoAllL1PFCandidates_)); + l1PFTau_.setIsoChargedHadrons(convertToRefVector(isoChargedHadrons_)); + l1PFTau_.setIsoElectrons(convertToRefVector(isoElectrons_)); + l1PFTau_.setIsoNeutralHadrons(convertToRefVector(isoNeutralHadrons_)); + l1PFTau_.setIsoPhotons(convertToRefVector(isoPhotons_)); + l1PFTau_.setIsoMuons(convertToRefVector(isoMuons_)); + + l1PFTau_.setSumAllL1PFCandidates(convertToRefVector(sumAllL1PFCandidates_)); + l1PFTau_.setSumChargedHadrons(convertToRefVector(sumChargedHadrons_)); + l1PFTau_.setSumElectrons(convertToRefVector(sumElectrons_)); + l1PFTau_.setSumNeutralHadrons(convertToRefVector(sumNeutralHadrons_)); + l1PFTau_.setSumPhotons(convertToRefVector(sumPhotons_)); + l1PFTau_.setSumMuons(convertToRefVector(sumMuons_)); + + l1PFTau_.setPrimaryVertex(primaryVertex_); + + if (l1PFTau_.signalChargedHadrons().size() > 1) { + if (stripP4_.pt() < 5.) + l1PFTau_.setTauType(l1t::L1HPSPFTau::kThreeProng0Pi0); + else + l1PFTau_.setTauType(l1t::L1HPSPFTau::kThreeProng1Pi0); + } else { + if (stripP4_.pt() < 5.) + l1PFTau_.setTauType(l1t::L1HPSPFTau::kOneProng0Pi0); + else + l1PFTau_.setTauType(l1t::L1HPSPFTau::kOneProng1Pi0); + } + + l1PFTau_.setStripP4(stripP4_); + + l1PFTau_.setSumAllL1PFCandidatesPt(sumAllL1PFCandidatesPt_); + l1PFTau_.setSignalConeSize(signalConeSize_); + l1PFTau_.setisolationConeSize(isolationConeSize_); + + double sumChargedIso = 0.; + double sumNeutralIso = 0.; + for (auto l1PFCand : isoAllL1PFCandidates_) { + if (l1PFCand->charge() != 0) { + sumChargedIso += l1PFCand->pt(); + } else if (l1PFCand->id() == l1t::PFCandidate::Photon) { + sumNeutralIso += l1PFCand->pt(); + } + } + l1PFTau_.setSumChargedIso(sumChargedIso); + l1PFTau_.setSumNeutralIso(sumNeutralIso); + const double weightNeutralIso = 1.; + const double offsetNeutralIso = 0.; + l1PFTau_.setSumCombinedIso(sumChargedIso + weightNeutralIso * (sumNeutralIso - offsetNeutralIso)); + l1PFTau_.setSumChargedIsoPileup(sumChargedIsoPileup_); + + if (l1PFTau_.sumChargedIso() < 20.0) { + l1PFTau_.setPassVLooseIso(true); + } + if (l1PFTau_.sumChargedIso() < 10.0) { + l1PFTau_.setPassLooseIso(true); + } + if (l1PFTau_.sumChargedIso() < 5.0) { + l1PFTau_.setPassMediumIso(true); + } + if (l1PFTau_.sumChargedIso() < 2.5) { + l1PFTau_.setPassTightIso(true); + } +} + +l1t::PFCandidateRefVector L1HPSPFTauBuilder::convertToRefVector(const std::vector& l1PFCands) { + l1t::PFCandidateRefVector l1PFCandsRefVector(l1PFCandProductID_); + for (auto l1PFCand : l1PFCands) { + l1PFCandsRefVector.push_back(l1PFCand); + } + return l1PFCandsRefVector; +} diff --git a/L1Trigger/Phase2L1Taus/src/L1HPSPFTauQualityCut.cc b/L1Trigger/Phase2L1Taus/src/L1HPSPFTauQualityCut.cc new file mode 100644 index 0000000000000..89508d7912a72 --- /dev/null +++ b/L1Trigger/Phase2L1Taus/src/L1HPSPFTauQualityCut.cc @@ -0,0 +1,105 @@ +#include "L1Trigger/Phase2L1Taus/interface/L1HPSPFTauQualityCut.h" +#include "FWCore/Utilities/interface/Exception.h" // cms::Exception + +L1HPSPFTauQualityCut::L1HPSPFTauQualityCut(const edm::ParameterSet& cfg) + : debug_(cfg.getUntrackedParameter("debug", false)) { + std::string pfCandTypeString = cfg.getParameter("pfCandType"); + if (pfCandTypeString == "chargedHadron") + pfCandType_ = l1t::PFCandidate::ChargedHadron; + else if (pfCandTypeString == "electron") + pfCandType_ = l1t::PFCandidate::Electron; + else if (pfCandTypeString == "muon") + pfCandType_ = l1t::PFCandidate::Muon; + else if (pfCandTypeString == "neutralHadron") + pfCandType_ = l1t::PFCandidate::NeutralHadron; + else if (pfCandTypeString == "photon") + pfCandType_ = l1t::PFCandidate::Photon; + else + throw cms::Exception("L1HPSPFTauQualityCut") + << "Invalid Configuration parameter 'pfCandType' = '" << pfCandTypeString << "' !!\n"; + + std::string dzCutString = cfg.getParameter("dzCut"); + if (dzCutString == "disabled") + dzCut_ = kDisabled; + else if (dzCutString == "enabled_primary") + dzCut_ = kEnabledPrimary; + else if (dzCutString == "enabled_pileup") + dzCut_ = kEnabledPileup; + else + throw cms::Exception("L1HPSPFTauQualityCut") + << "Invalid Configuration parameter 'dzCut' = '" << dzCutString << "' !!\n"; + + minPt_ = cfg.getParameter("minPt"); + maxDz_ = (cfg.exists("maxDz")) ? cfg.getParameter("maxDz") : 1.e+3; + + if (debug_ && dzCut_ == kEnabledPrimary) { + std::cout << " applying pT > " << minPt_ << " GeV && dz < " << maxDz_ << " cm to PFCands of type = '" + << pfCandTypeString << "'" << std::endl; + } +} + +L1HPSPFTauQualityCut::~L1HPSPFTauQualityCut() {} + +bool L1HPSPFTauQualityCut::operator()(const l1t::PFCandidate& pfCand, float_t primaryVertex_z) const { + if (pfCand.id() == pfCandType_) { + if (pfCand.pt() < minPt_) { + return false; + } + + if (pfCand.charge() != 0) { + if (dzCut_ == kEnabledPrimary || dzCut_ == kEnabledPileup) { + l1t::PFTrackRef pfCand_track = pfCand.pfTrack(); + double dz = std::fabs(pfCand_track->vertex().z() - primaryVertex_z); + if (dzCut_ == kEnabledPrimary && dz > maxDz_) + return false; + if (dzCut_ == kEnabledPileup && dz <= maxDz_) + return false; + } + } else if (dzCut_ == kEnabledPileup) { + return false; // CV: only consider charged PFCands as originating from pileup + } + } + return true; +} + +l1t::PFCandidate::ParticleType L1HPSPFTauQualityCut::pfCandType() const { return pfCandType_; } + +int L1HPSPFTauQualityCut::dzCut() const { return dzCut_; } + +float_t L1HPSPFTauQualityCut::minPt() const { return minPt_; } + +float_t L1HPSPFTauQualityCut::maxDz() const { return maxDz_; } + +L1HPSPFTauQualityCut readL1PFTauQualityCut(const edm::ParameterSet& cfg, + const std::string& pfCandType, + const std::string& dzCut, + bool debug) { + edm::ParameterSet cfg_pfCandType = cfg.getParameter(pfCandType); + cfg_pfCandType.addParameter("pfCandType", pfCandType); + cfg_pfCandType.addParameter("dzCut", dzCut); + cfg_pfCandType.addUntrackedParameter("debug", debug); + L1HPSPFTauQualityCut qualityCut(cfg_pfCandType); + return qualityCut; +} + +std::vector readL1PFTauQualityCuts(const edm::ParameterSet& cfg, + const std::string& dzCut, + bool debug) { + std::vector qualityCuts; + qualityCuts.push_back(readL1PFTauQualityCut(cfg, "chargedHadron", dzCut, debug)); + qualityCuts.push_back(readL1PFTauQualityCut(cfg, "electron", dzCut, debug)); + qualityCuts.push_back(readL1PFTauQualityCut(cfg, "muon", dzCut, debug)); + qualityCuts.push_back(readL1PFTauQualityCut(cfg, "photon", dzCut, debug)); + qualityCuts.push_back(readL1PFTauQualityCut(cfg, "neutralHadron", dzCut, debug)); + return qualityCuts; +} + +bool isSelected(const std::vector& qualityCuts, + const l1t::PFCandidate& pfCand, + float_t primaryVertex_z) { + for (auto qualityCut : qualityCuts) { + if (!qualityCut(pfCand, primaryVertex_z)) + return false; + } + return true; +} diff --git a/L1Trigger/Phase2L1Taus/test/produceL1HPSPFTaus_cfg.py b/L1Trigger/Phase2L1Taus/test/produceL1HPSPFTaus_cfg.py new file mode 100644 index 0000000000000..4ff553c01bfbc --- /dev/null +++ b/L1Trigger/Phase2L1Taus/test/produceL1HPSPFTaus_cfg.py @@ -0,0 +1,207 @@ +import FWCore.ParameterSet.Config as cms +from Configuration.StandardSequences.Eras import eras +from Configuration.ProcessModifiers.convertHGCalDigisSim_cff import convertHGCalDigisSim +from Configuration.Eras.Era_Phase2C9_cff import Phase2C9 +process = cms.Process('Produce',Phase2C9) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.Geometry.GeometryExtended2026D49Reco_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(10) +) + +# Input source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( + '/store/mc/Phase2HLTTDRSummer20ReRECOMiniAOD/VBFHToTauTau_M125_14TeV_powheg_pythia8_correctedGridpack_tuneCP5/FEVT/PU200_111X_mcRun4_realistic_T15_v1-v1/120000/084C8B72-BC64-DE46-801F-D971D5A34F62.root' + ), + inputCommands = cms.untracked.vstring("keep *", + "drop l1tEMTFHit2016Extras_simEmtfDigis_CSC_HLT", + "drop l1tEMTFHit2016Extras_simEmtfDigis_RPC_HLT", + "drop l1tEMTFHit2016s_simEmtfDigis__HLT", + "drop l1tEMTFTrack2016Extras_simEmtfDigis__HLT", + "drop l1tEMTFTrack2016s_simEmtfDigis__HLT", + 'drop l1tEMTFHit2016Extras_simEmtfDigis_CSC_HLT', + 'drop l1tEMTFHit2016Extras_simEmtfDigis_RPC_HLT', + 'drop l1tEMTFHit2016s_simEmtfDigis__HLT', + 'drop l1tEMTFTrack2016Extras_simEmtfDigis__HLT', + 'drop l1tEMTFTrack2016s_simEmtfDigis__HLT', + ), +) + +process.options = cms.untracked.PSet( + +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('step2 nevts:1'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Other statements +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic', '') + +# Sequence, Path and EndPath definitions +process.productionSequence = cms.Sequence() + +process.load('SimCalorimetry.HcalTrigPrimProducers.hcaltpdigi_cff') +process.load('CalibCalorimetry.CaloTPG.CaloTPGTranscoder_cfi') + +process.load('L1Trigger.L1THGCal.hgcalTriggerPrimitives_cff') +process.productionSequence += process.hgcalTriggerPrimitives + +process.load('SimCalorimetry.EcalEBTrigPrimProducers.ecalEBTriggerPrimitiveDigis_cff') +process.productionSequence += process.simEcalEBTriggerPrimitiveDigis + +process.load("L1Trigger.TrackFindingTracklet.Tracklet_cfi") +L1TRK_PROC = process.TTTracksFromTrackletEmulation +L1TRK_NAME = "TTTracksFromTrackletEmulation" +L1TRK_LABEL = "Level1TTTracks" + +process.load("RecoVertex.BeamSpotProducer.BeamSpot_cfi") +process.productionSequence += process.offlineBeamSpot + +process.productionSequence += process.TTTracksFromTrackletEmulation + +process.load("SimTracker.TrackTriggerAssociation.TrackTriggerAssociator_cff") +process.TTTrackAssociatorFromPixelDigis.TTTracks = cms.VInputTag( cms.InputTag(L1TRK_NAME, L1TRK_LABEL) ) +process.productionSequence += process.TrackTriggerAssociatorTracks + +process.load("L1Trigger.L1TTrackMatch.L1TkPrimaryVertexProducer_cfi") +process.productionSequence += process.L1TkPrimaryVertex + +process.load('Configuration.StandardSequences.SimL1Emulator_cff') +process.productionSequence += process.SimL1Emulator + +process.load("L1Trigger.Phase2L1ParticleFlow.pfTracksFromL1Tracks_cfi") +process.productionSequence += process.pfTracksFromL1Tracks + +process.load("L1Trigger.Phase2L1ParticleFlow.l1ParticleFlow_cff") +process.productionSequence += process.l1ParticleFlow + +process.load('L1Trigger.L1CaloTrigger.Phase1L1TJets_cff') +process.productionSequence += process.Phase1L1TJetsSequence + +############################################################ +# Generator-level (visible) hadronic taus +############################################################ + +process.load("PhysicsTools.JetMCAlgos.TauGenJets_cfi") +process.tauGenJets.GenParticles = cms.InputTag("genParticles") +process.load("PhysicsTools.JetMCAlgos.TauGenJetsDecayModeSelectorAllHadrons_cfi") +process.genTaus = cms.Sequence(process.tauGenJets + process.tauGenJetsSelectorAllHadrons) +process.productionSequence += process.genTaus + +############################################################ +# produce L1 HPS PF Tau objects +############################################################ + +from L1Trigger.Phase2L1Taus.L1HPSPFTauProducerPF_cfi import L1HPSPFTauProducerPF +from L1Trigger.Phase2L1Taus.L1HPSPFTauProducerPuppi_cfi import L1HPSPFTauProducerPuppi +for useStrips in [ True, False ]: + for applyPreselection in [ True, False ]: + moduleNameBase = "L1HPSPFTauProducer" + if useStrips and applyPreselection: + moduleNameBase += "WithStripsAndPreselection" + elif useStrips and not applyPreselection: + moduleNameBase += "WithStripsWithoutPreselection" + elif not useStrips and applyPreselection: + moduleNameBase += "WithoutStripsWithPreselection" + elif not useStrips and not applyPreselection: + moduleNameBase += "WithoutStripsAndPreselection" + else: + raise ValueError("Invalid Combination of 'useStrips' and 'applyPreselection' Configuration parameters !!") + + moduleNamePF = moduleNameBase + "PF" + modulePF = L1HPSPFTauProducerPF.clone( + useStrips = cms.bool(useStrips), + applyPreselection = cms.bool(applyPreselection), + debug = cms.untracked.bool(False) + ) + setattr(process, moduleNamePF, modulePF) + process.productionSequence += getattr(process, moduleNamePF) + + moduleNamePuppi = moduleNameBase + "Puppi" + modulePuppi = L1HPSPFTauProducerPuppi.clone( + useStrips = cms.bool(useStrips), + applyPreselection = cms.bool(applyPreselection), + debug = cms.untracked.bool(False) + ) + setattr(process, moduleNamePuppi, modulePuppi) + process.productionSequence += getattr(process, moduleNamePuppi) + + +process.production_step = cms.Path(process.productionSequence) + +############################################################ +# write output file +############################################################ + +process.out = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string("NTuple_L1HPSPFTauProducer_part_1.root"), + SelectEvents = cms.untracked.PSet( + SelectEvents = cms.vstring('production_step') + ), + outputCommands = cms.untracked.vstring( + 'drop *_*_*_*', + 'keep *_l1pfCandidates_PF_*', + 'keep *_l1pfCandidates_Puppi_*', + 'keep *_l1pfProducer*_z0_*', + 'keep *_pfTracksFromL1Tracks*_*_*', + 'keep *_pfClustersFrom*_*_*', + 'keep *_TTTracksFromTracklet_*_*', + 'keep *_VertexProducer_*_*', + 'keep *_L1TkPrimaryVertex_*_*', + 'keep *_slimmedTaus_*_*', + 'keep *_packedPFCandidates_*_*', + 'keep *_generator_*_*', + 'keep *_caloStage2Digis_*_*', + 'keep *_L1HPSPFTauProducer*PF_*_*', + 'keep *_L1HPSPFTauProducer*Puppi_*_*', + 'keep *_prunedGenParticles_*_*', + 'keep *_tauGenJetsSelectorAllHadrons_*_*', + 'keep *_particleFlow_*_*', + 'keep *_generalTracks_*_*', + 'keep *_electronGsfTracks_*_*', + 'keep *_offlineSlimmedPrimaryVertices_*_*', + 'keep *_L1PFTauProducer_*_*', + 'keep *_slimmedAddPileupInfo_*_*', + "keep *_Phase1L1TJetProducer_*_*", + ) +) +process.outpath = cms.EndPath(process.out) + +process.endjob_step = cms.EndPath(process.endOfProcess) + +# Schedule definition +process.schedule = cms.Schedule(process.production_step, process.outpath, process.endjob_step) + +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion + +# Enable module run-time report +#process.options = cms.untracked.PSet( +# wantSummary = cms.untracked.bool(True) +#) + +dump_file = open('dump.py','w') +dump_file.write(process.dumpPython()) + +process.options.numberOfThreads = cms.untracked.uint32(2)