DataFormats/Phase2L1Taus is merged with DataFormats/L1TParticleFlow

(cherry picked from commit 21829a0)

DataFormats/L1TParticleFlow/BuildFile.xml

@@ -5,6 +5,7 @@
 <use name="DataFormats/L1TCorrelator"/>
 <use name="FWCore/Utilities"/>
 <use name="rootrflx"/>
+
 <export>
   <lib name="1"/>
 </export>

DataFormats/L1TParticleFlow/interface/HPSPFTau.h

@@ -2,7 +2,7 @@
 #define DataFormats_L1TParticleFlow_HPSPFTau_H
 
 #include "DataFormats/L1TParticleFlow/interface/PFCandidate.h"  // l1t::PFCandidate, l1t::PFCandidateRef, l1t::PFCandidateRefVector
-#include "DataFormats/L1TParticleFlow/interface/PFJet.h"    // l1t::PFJet, l1t::PFJetCollection, l1t::PFJetRef
+#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"
@@ -17,14 +17,14 @@ namespace l1t {
     HPSPFTau();
 
     /// destructor
-    ~HPSPFTau() override;
+    ~HPSPFTau();
 
     /// accessor functions for reco level quantities
     bool isChargedPFCandSeeded() const { return seedChargedPFCand_.isNonnull(); }
-    bool isPFJetSeeded() const { return seedPFJet_.isNonnull(); }
+    bool isJetSeeded() const { return seedJet_.isNonnull(); }
 
     const l1t::PFCandidateRef& seedChargedPFCand() const { return seedChargedPFCand_; }
-    const l1t::PFJetRef& seedPFJet() const { return seedPFJet_; }
+    const reco::CaloJetRef& seedJet() const { return seedJet_; }
     const l1t::PFCandidateRef& leadChargedPFCand() const { return leadChargedPFCand_; }
 
     const l1t::PFCandidateRefVector& signalAllL1PFCandidates() const { return signalAllL1PFCandidates_; }
@@ -57,17 +57,16 @@ namespace l1t {
     enum Kind { kUndefined, kOneProng0Pi0, kOneProng1Pi0, kThreeProng0Pi0, kThreeProng1Pi0 };
     Kind tauType() const { return tauType_; }
 
-    const reco::Particle::LorentzVector& strip_p4() const { return strip_p4_; }
+    const reco::Particle::LorentzVector& stripP4() const { return stripP4_; }
 
-    float sumAllL1PFCandidates_pt() const { return sumAllL1PFCandidates_pt_; }
+    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_; }
-    float rhoCorr() const { return rhoCorr_; }
 
     bool passTightIso() const { return passTightIso_; }
     bool passMediumIso() const { return passMediumIso_; }
@@ -79,9 +78,75 @@ namespace l1t {
     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_;
-    l1t::PFJetRef seedPFJet_;
+    reco::CaloJetRef seedJet_;
     l1t::PFCandidateRef leadChargedPFCand_;
 
     l1t::PFCandidateRefVector signalAllL1PFCandidates_;
@@ -112,17 +177,16 @@ namespace l1t {
     l1t::TkPrimaryVertexRef primaryVertex_;
     Kind tauType_;
 
-    reco::Particle::LorentzVector strip_p4_;
+    reco::Particle::LorentzVector stripP4_;
 
-    float sumAllL1PFCandidates_pt_;
+    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)
-    float rhoCorr_;              // rho correction (maybe useful for applying pile-up corrections to neutral isolation)
 
     bool passTightIso_;
     bool passMediumIso_;
@@ -135,11 +199,12 @@ namespace l1t {
     bool passVLooseRelIso_;
   };
 
-  void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, const l1t::TkPrimaryVertexRef& primaryVertex);
-  void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, float primaryVertex_z);
 }  // namespace l1t
 
 /// print to stream
 std::ostream& operator<<(std::ostream& os, const l1t::HPSPFTau& l1PFTau);
 
+void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, const l1t::TkPrimaryVertexRef& primaryVertex);
+void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, float primaryVertexZ);
+
 #endif

DataFormats/L1TParticleFlow/interface/HPSPFTauFwd.h

@@ -1,14 +1,9 @@
 #ifndef DataFormats_L1TParticleFlow_HPSPFTauFwd_H
 #define DataFormats_L1TParticleFlow_HPSPFTauFwd_H
 
-#include <vector>
-#include "DataFormats/Common/interface/Ref.h"
-#include "DataFormats/Common/interface/RefVector.h"
+#include "DataFormats/L1TParticleFlow/interface/HPSPFTau.h"
 
 namespace l1t {
-
-  class HPSPFTau;
-
   typedef std::vector<HPSPFTau> HPSPFTauCollection;
 
   typedef edm::Ref<HPSPFTauCollection> HPSPFTauRef;

DataFormats/L1TParticleFlow/src/HPSPFTau.cc

@@ -1,5 +1,4 @@
 #include "DataFormats/L1TParticleFlow/interface/HPSPFTau.h"
-#include "FWCore/Utilities/interface/Exception.h"
 
 // default constructor
 l1t::HPSPFTau::HPSPFTau()
@@ -8,7 +7,6 @@ l1t::HPSPFTau::HPSPFTau()
       sumNeutralIso_(0.),
       sumCombinedIso_(0.),
       sumChargedIsoPileup_(0.),
-      rhoCorr_(0.),
       passTightIso_(false),
       passMediumIso_(false),
       passLooseIso_(false),
@@ -34,57 +32,53 @@ ostream& operator<<(ostream& os, const l1t::HPSPFTau& l1PFTau) {
   os << "seed:";
   if (l1PFTau.isChargedPFCandSeeded()) {
     os << " chargedPFCand";
-  } else if (l1PFTau.isPFJetSeeded()) {
+  } else if (l1PFTau.isJetSeeded()) {
     os << " PFJet";
-  } else {
-    cms::Exception ex("InconsistentTau");
-    ex.addContext("Calling HPSPFTau::operator <<");
-    ex.addAdditionalInfo("This tau is not seed by either a chargedPFCand or a PFJet!");
-    throw ex;
-  }
+  } else
+    assert(0);
   os << std::endl;
   os << "signalPFCands:" << std::endl;
-  for (const auto& l1PFCand : l1PFTau.signalAllL1PFCandidates()) {
+  for (auto l1PFCand : l1PFTau.signalAllL1PFCandidates()) {
     printPFCand(os, *l1PFCand, l1PFTau.primaryVertex());
   }
   os << "stripPFCands:" << std::endl;
-  for (const auto& l1PFCand : l1PFTau.stripAllL1PFCandidates()) {
+  for (auto l1PFCand : l1PFTau.stripAllL1PFCandidates()) {
     printPFCand(os, *l1PFCand, l1PFTau.primaryVertex());
   }
-  os << "strip pT = " << l1PFTau.strip_p4().pt() << std::endl;
+  os << "strip pT = " << l1PFTau.stripP4().pt() << std::endl;
   os << "isolationPFCands:" << std::endl;
-  for (const auto& l1PFCand : l1PFTau.isoAllL1PFCandidates()) {
+  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 l1t::printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, const l1t::TkPrimaryVertexRef& primaryVertex) {
-  float primaryVertex_z = (primaryVertex.isNonnull()) ? primaryVertex->zvertex() : 0.;
-  l1t::printPFCand(os, l1PFCand, primaryVertex_z);
+void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, const l1t::TkPrimaryVertexRef& primaryVertex) {
+  float primaryVertexZ = (primaryVertex.isNonnull()) ? primaryVertex->zvertex() : 0.;
+  printPFCand(os, l1PFCand, primaryVertexZ);
 }
 
-void l1t::printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, float primaryVertex_z) {
-  std::string type_string;
+void printPFCand(ostream& os, const l1t::PFCandidate& l1PFCand, float primaryVertexZ) {
+  std::string typeString;
   if (l1PFCand.id() == l1t::PFCandidate::ChargedHadron)
-    type_string = "PFChargedHadron";
+    typeString = "PFChargedHadron";
   else if (l1PFCand.id() == l1t::PFCandidate::Electron)
-    type_string = "PFElectron";
+    typeString = "PFElectron";
   else if (l1PFCand.id() == l1t::PFCandidate::NeutralHadron)
-    type_string = "PFNeutralHadron";
+    typeString = "PFNeutralHadron";
   else if (l1PFCand.id() == l1t::PFCandidate::Photon)
-    type_string = "PFPhoton";
+    typeString = "PFPhoton";
   else if (l1PFCand.id() == l1t::PFCandidate::Muon)
-    type_string = "PFMuon";
+    typeString = "PFMuon";
   else
-    type_string = "N/A";
-  os << " " << type_string << " with pT = " << l1PFCand.pt() << ", eta = " << l1PFCand.eta()
+    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 && primaryVertex_z != 0.) {
-    os << " (dz = " << std::fabs(l1PFCand.pfTrack()->vertex().z() - primaryVertex_z) << ")";
+  if (l1PFCand.charge() != 0 && primaryVertexZ != 0.) {
+    os << " (dz = " << std::fabs(l1PFCand.pfTrack()->vertex().z() - primaryVertexZ) << ")";
   }
   os << std::endl;
 }

DataFormats/L1TParticleFlow/src/classes_def.xml

@@ -44,8 +44,8 @@
   <class name="edm::RefVector<l1t::PFTauCollection>" /> 
   <class name="std::vector<edm::Ref<l1t::PFTauCollection> >" /> 
 
-  <class name="l1t::HPSPFTau" ClassVersion="11">
-   <version ClassVersion="11" checksum="98678086"/>
+  <class name="l1t::HPSPFTau" ClassVersion="12">
+   <version ClassVersion="12" checksum="1127525942"/>
   </class>
   <class name="l1t::HPSPFTauCollection"/>
   <class name="edm::Wrapper<l1t::HPSPFTauCollection>"/>