PileupJetIdAlgo Class Reference

#include <PileupJetIdAlgo.h>

Classes
class	AlgoGBRForestsAndConstants

Public Types
typedef std::map< std::string, std::pair< float *, float > >	variables_list_t
enum	version_t { USER = -1, PHILv0 = 0 }

Public Member Functions
int	computeCutIDflag (float betaStarClassic, float dR2Mean, float nvtx, float jetPt, float jetEta)
int	computeIDflag (float mva, float jetPt, float jetEta)
int	computeIDflag (float mva, int ptId, int etaId)
PileupJetIdentifier	computeIdVariables (const reco::Jet *jet, float jec, const reco::Vertex *, const reco::VertexCollection &, double rho, bool usePuppi)
PileupJetIdentifier	computeMva ()
std::string	dumpVariables () const
std::pair< int, int >	getJetIdKey (float jetPt, float jetEta)
float	getMVAval (const std::vector< std::string > &, const std::unique_ptr< const GBRForest > &)
const variables_list_t &	getVariables () const
	const PileupJetIdentifier::variables_list_t & getVariables() const { return variables_; }; More...
const std::string	method () const
	PileupJetIdAlgo (AlgoGBRForestsAndConstants const *cache)
void	set (const PileupJetIdentifier &)
	~PileupJetIdAlgo ()

Protected Member Functions
void	initVariables ()
void	resetVariables ()
void	runMva ()

Protected Attributes
AlgoGBRForestsAndConstants const *	cache_
PileupJetIdentifier	internalId_
variables_list_t	variables_

Detailed Description

Definition at line 22 of file PileupJetIdAlgo.h.

Member Typedef Documentation

variables_list_t

typedef std::map<std::string, std::pair<float*, float> > PileupJetIdAlgo::variables_list_t

Definition at line 41 of file PileupJetIdAlgo.h.

Member Enumeration Documentation

version_t

enum PileupJetIdAlgo::version_t

Enumerator
USER
PHILv0

Definition at line 24 of file PileupJetIdAlgo.h.

{ USER = -1, PHILv0 = 0 };

Constructor & Destructor Documentation

PileupJetIdAlgo()

PileupJetIdAlgo::PileupJetIdAlgo

(

AlgoGBRForestsAndConstants const *

cache

)

Definition at line 125 of file PileupJetIdAlgo.cc.

: cache_(cache) { initVariables(); }

References initVariables().

~PileupJetIdAlgo()

PileupJetIdAlgo::~PileupJetIdAlgo

(

)

Definition at line 128 of file PileupJetIdAlgo.cc.

{}

Member Function Documentation

computeCutIDflag()

int PileupJetIdAlgo::computeCutIDflag	(	float	betaStarClassic,
		float	dR2Mean,
		float	nvtx,
		float	jetPt,
		float	jetEta
	)

Definition at line 209 of file PileupJetIdAlgo.cc.

                                                                                                                 {
  std::pair<int, int> jetIdKey = getJetIdKey(jetPt, jetEta);
  float betaStarModified = betaStarClassic / log(nvtx - 0.64);
  int idFlag(0);
  if (betaStarModified < cache_->betaStarCut()[PileupJetIdentifier::kTight][jetIdKey.first][jetIdKey.second] &&
      dR2Mean < cache_->rmsCut()[PileupJetIdentifier::kTight][jetIdKey.first][jetIdKey.second])
    idFlag += 1 << PileupJetIdentifier::kTight;
 
  if (betaStarModified < cache_->betaStarCut()[PileupJetIdentifier::kMedium][jetIdKey.first][jetIdKey.second] &&
      dR2Mean < cache_->rmsCut()[PileupJetIdentifier::kMedium][jetIdKey.first][jetIdKey.second])
    idFlag += 1 << PileupJetIdentifier::kMedium;
 
  if (betaStarModified < cache_->betaStarCut()[PileupJetIdentifier::kLoose][jetIdKey.first][jetIdKey.second] &&
      dR2Mean < cache_->rmsCut()[PileupJetIdentifier::kLoose][jetIdKey.first][jetIdKey.second])
    idFlag += 1 << PileupJetIdentifier::kLoose;
  return idFlag;
}

References getJetIdKey(), reco::btau::jetEta, reco::btau::jetPt, PileupJetIdentifier::kLoose, PileupJetIdentifier::kMedium, PileupJetIdentifier::kTight, and dqm-mbProfile::log.

Referenced by runMva().

computeIDflag() [1/2]

int PileupJetIdAlgo::computeIDflag	(	float	mva,
		float	jetPt,
		float	jetEta
	)

Definition at line 227 of file PileupJetIdAlgo.cc.

                                                                       {
  std::pair<int, int> jetIdKey = getJetIdKey(jetPt, jetEta);
  return computeIDflag(mva, jetIdKey.first, jetIdKey.second);
}

References getJetIdKey(), reco::btau::jetEta, reco::btau::jetPt, and beam_dqm_sourceclient-live_cfg::mva.

Referenced by runMva().

computeIDflag() [2/2]

int PileupJetIdAlgo::computeIDflag	(	float	mva,
		int	ptId,
		int	etaId
	)

Definition at line 233 of file PileupJetIdAlgo.cc.

                                                                 {
  int idFlag(0);
  if (mva > cache_->mvacut()[PileupJetIdentifier::kTight][ptId][etaId])
    idFlag += 1 << PileupJetIdentifier::kTight;
  if (mva > cache_->mvacut()[PileupJetIdentifier::kMedium][ptId][etaId])
    idFlag += 1 << PileupJetIdentifier::kMedium;
  if (mva > cache_->mvacut()[PileupJetIdentifier::kLoose][ptId][etaId])
    idFlag += 1 << PileupJetIdentifier::kLoose;
  return idFlag;
}

References cache_, PileupJetIdentifier::kLoose, PileupJetIdentifier::kMedium, PileupJetIdentifier::kTight, beam_dqm_sourceclient-live_cfg::mva, and PileupJetIdAlgo::AlgoGBRForestsAndConstants::mvacut().

computeIdVariables()

PileupJetIdentifier PileupJetIdAlgo::computeIdVariables	(	const reco::Jet *	jet,
		float	jec,
		const reco::Vertex *	vtx,
		const reco::VertexCollection &	allvtx,
		double	rho,
		bool	usePuppi
	)

Definition at line 251 of file PileupJetIdAlgo.cc.

                                                                       {
  // initialize all variables to 0
  resetVariables();
 
  // loop over constituents, accumulate sums and find leading candidates
  const pat::Jet* patjet = dynamic_cast<const pat::Jet*>(jet);
  const reco::PFJet* pfjet = dynamic_cast<const reco::PFJet*>(jet);
  assert(patjet != nullptr || pfjet != nullptr);
  if (patjet != nullptr && jec == 0.) {  // if this is a pat jet and no jec has been passed take the jec from the object
    jec = patjet->pt() / patjet->correctedJet(0).pt();
  }
  if (jec <= 0.) {
    jec = 1.;
  }
 
  const reco::Candidate *lLead = nullptr, *lSecond = nullptr, *lLeadNeut = nullptr, *lLeadEm = nullptr,
                        *lLeadCh = nullptr, *lTrail = nullptr;
  std::vector<float> frac, fracCh, fracEm, fracNeut;
  float cones[] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7};
  size_t ncones = sizeof(cones) / sizeof(float);
  float* coneFracs[] = {&internalId_.frac01_,
                        &internalId_.frac02_,
                        &internalId_.frac03_,
                        &internalId_.frac04_,
                        &internalId_.frac05_,
                        &internalId_.frac06_,
                        &internalId_.frac07_};
  float* coneEmFracs[] = {&internalId_.emFrac01_,
                          &internalId_.emFrac02_,
                          &internalId_.emFrac03_,
                          &internalId_.emFrac04_,
                          &internalId_.emFrac05_,
                          &internalId_.emFrac06_,
                          &internalId_.emFrac07_};
  float* coneNeutFracs[] = {&internalId_.neutFrac01_,
                            &internalId_.neutFrac02_,
                            &internalId_.neutFrac03_,
                            &internalId_.neutFrac04_,
                            &internalId_.neutFrac05_,
                            &internalId_.neutFrac06_,
                            &internalId_.neutFrac07_};
  float* coneChFracs[] = {&internalId_.chFrac01_,
                          &internalId_.chFrac02_,
                          &internalId_.chFrac03_,
                          &internalId_.chFrac04_,
                          &internalId_.chFrac05_,
                          &internalId_.chFrac06_,
                          &internalId_.chFrac07_};
  TMatrixDSym covMatrix(2);
  covMatrix = 0.;
  float jetPt = jet->pt() / jec;  // use uncorrected pt for shape variables
  float sumPt = 0., sumPt2 = 0., sumTkPt = 0., sumPtCh = 0, sumPtNe = 0;
  float multNeut = 0.0;
  setPtEtaPhi(
      *jet, internalId_.jetPt_, internalId_.jetEta_, internalId_.jetPhi_);  // use corrected pt for jet kinematics
  internalId_.jetM_ = jet->mass();
  internalId_.nvtx_ = allvtx.size();
  internalId_.rho_ = rho;
 
  float dRmin(1000);
 
  for (unsigned i = 0; i < jet->numberOfSourceCandidatePtrs(); ++i) {
    reco::CandidatePtr pfJetConstituent = jet->sourceCandidatePtr(i);
 
    const reco::Candidate* icand = pfJetConstituent.get();
    const pat::PackedCandidate* lPack = dynamic_cast<const pat::PackedCandidate*>(icand);
    const reco::PFCandidate* lPF = dynamic_cast<const reco::PFCandidate*>(icand);
    bool isPacked = true;
    if (lPack == nullptr) {
      isPacked = false;
    }
    float candPuppiWeight = 1.0;
    if (usePuppi && isPacked)
      candPuppiWeight = lPack->puppiWeight();
    float candPt = (icand->pt()) * candPuppiWeight;
    float candPtFrac = candPt / jetPt;
    float candDr = reco::deltaR(*icand, *jet);
    float candDeta = icand->eta() - jet->eta();
    float candDphi = reco::deltaPhi(*icand, *jet);
    float candPtDr = candPt * candDr;
    size_t icone = std::lower_bound(&cones[0], &cones[ncones], candDr) - &cones[0];
 
    if (candDr < dRmin)
      dRmin = candDr;
 
    // // all particles
    if (lLead == nullptr || candPt > lLead->pt()) {
      lSecond = lLead;
      lLead = icand;
    } else if ((lSecond == nullptr || candPt > lSecond->pt()) && (candPt < lLead->pt())) {
      lSecond = icand;
    }
 
    // // average shapes
    internalId_.dRMean_ += candPtDr;
    internalId_.dR2Mean_ += candPtDr * candPtDr;
    covMatrix(0, 0) += candPt * candPt * candDeta * candDeta;
    covMatrix(0, 1) += candPt * candPt * candDeta * candDphi;
    covMatrix(1, 1) += candPt * candPt * candDphi * candDphi;
    internalId_.ptD_ += candPt * candPt;
    sumPt += candPt;
    sumPt2 += candPt * candPt;
 
    // single most energetic candiates and jet shape profiles
    frac.push_back(candPtFrac);
 
    if (icone < ncones) {
      *coneFracs[icone] += candPt;
    }
 
    // neutrals
    if (abs(icand->pdgId()) == 130) {
      if (lLeadNeut == nullptr || candPt > lLeadNeut->pt()) {
        lLeadNeut = icand;
      }
      internalId_.dRMeanNeut_ += candPtDr;
      fracNeut.push_back(candPtFrac);
      if (icone < ncones) {
        *coneNeutFracs[icone] += candPt;
      }
      internalId_.ptDNe_ += candPt * candPt;
      sumPtNe += candPt;
      multNeut += candPuppiWeight;
    }
    // EM candidated
    if (icand->pdgId() == 22) {
      if (lLeadEm == nullptr || candPt > lLeadEm->pt()) {
        lLeadEm = icand;
      }
      internalId_.dRMeanEm_ += candPtDr;
      fracEm.push_back(candPtFrac);
      if (icone < ncones) {
        *coneEmFracs[icone] += candPt;
      }
      internalId_.ptDNe_ += candPt * candPt;
      sumPtNe += candPt;
      multNeut += candPuppiWeight;
    }
    if ((abs(icand->pdgId()) == 1) || (abs(icand->pdgId()) == 2))
      multNeut += candPuppiWeight;
 
    // Charged  particles
    if (icand->charge() != 0) {
      if (lLeadCh == nullptr || candPt > lLeadCh->pt()) {
        lLeadCh = icand;
 
        const reco::Track* pfTrk = icand->bestTrack();
        if (lPF && std::abs(icand->pdgId()) == 13 && pfTrk == nullptr) {
          reco::MuonRef lmuRef = lPF->muonRef();
          if (lmuRef.isNonnull()) {
            const reco::Muon& lmu = *lmuRef.get();
            pfTrk = lmu.bestTrack();
            edm::LogWarning("BadMuon")
                << "Found a PFCandidate muon without a trackRef: falling back to Muon::bestTrack ";
          }
        }
        if (pfTrk == nullptr) {  //protection against empty pointers for the miniAOD case
          //To handle the electron case
          if (isPacked) {
            internalId_.d0_ = std::abs(lPack->dxy(vtx->position()));
            internalId_.dZ_ = std::abs(lPack->dz(vtx->position()));
          } else if (lPF != nullptr) {
            pfTrk = (lPF->trackRef().get() == nullptr) ? lPF->gsfTrackRef().get() : lPF->trackRef().get();
            internalId_.d0_ = std::abs(pfTrk->dxy(vtx->position()));
            internalId_.dZ_ = std::abs(pfTrk->dz(vtx->position()));
          }
        } else {
          internalId_.d0_ = std::abs(pfTrk->dxy(vtx->position()));
          internalId_.dZ_ = std::abs(pfTrk->dz(vtx->position()));
        }
      }
      internalId_.dRMeanCh_ += candPtDr;
      internalId_.ptDCh_ += candPt * candPt;
      fracCh.push_back(candPtFrac);
      if (icone < ncones) {
        *coneChFracs[icone] += candPt;
      }
      sumPtCh += candPt;
    }
    // // beta and betastar
    if (icand->charge() != 0) {
      if (!isPacked) {
        if (lPF->trackRef().isNonnull()) {
          float tkpt = candPt;
          sumTkPt += tkpt;
          // 'classic' beta definition based on track-vertex association
          bool inVtx0 = vtx->trackWeight(lPF->trackRef()) > 0;
 
          bool inAnyOther = false;
          // alternative beta definition based on track-vertex distance of closest approach
          double dZ0 = std::abs(lPF->trackRef()->dz(vtx->position()));
          double dZ = dZ0;
          for (reco::VertexCollection::const_iterator vi = allvtx.begin(); vi != allvtx.end(); ++vi) {
            const reco::Vertex& iv = *vi;
            if (iv.isFake() || iv.ndof() < 4) {
              continue;
            }
            // the primary vertex may have been copied by the user: check identity by position
            bool isVtx0 = (iv.position() - vtx->position()).r() < 0.02;
            // 'classic' beta definition: check if the track is associated with
            // any vertex other than the primary one
            if (!isVtx0 && !inAnyOther) {
              inAnyOther = vtx->trackWeight(lPF->trackRef()) <= 0;
            }
            // alternative beta: find closest vertex to the track
            dZ = std::min(dZ, std::abs(lPF->trackRef()->dz(iv.position())));
          }
          // classic beta/betaStar
          if (inVtx0 && !inAnyOther) {
            internalId_.betaClassic_ += tkpt;
          } else if (!inVtx0 && inAnyOther) {
            internalId_.betaStarClassic_ += tkpt;
          }
          // alternative beta/betaStar
          if (dZ0 < 0.2) {
            internalId_.beta_ += tkpt;
          } else if (dZ < 0.2) {
            internalId_.betaStar_ += tkpt;
          }
        }
      } else {
        float tkpt = candPt;
        sumTkPt += tkpt;
        bool inVtx0 = false;
        bool inVtxOther = false;
        double dZ0 = 9999.;
        double dZ_tmp = 9999.;
        for (unsigned vtx_i = 0; vtx_i < allvtx.size(); vtx_i++) {
          auto iv = allvtx[vtx_i];
 
          if (iv.isFake())
            continue;
 
          // Match to vertex in case of copy as above
          bool isVtx0 = (iv.position() - vtx->position()).r() < 0.02;
 
          if (isVtx0) {
            if (lPack->fromPV(vtx_i) == pat::PackedCandidate::PVUsedInFit)
              inVtx0 = true;
            if (lPack->fromPV(vtx_i) == 0)
              inVtxOther = true;
            dZ0 = lPack->dz(iv.position());
          }
 
          if (fabs(lPack->dz(iv.position())) < fabs(dZ_tmp)) {
            dZ_tmp = lPack->dz(iv.position());
          }
        }
        if (inVtx0) {
          internalId_.betaClassic_ += tkpt;
        } else if (inVtxOther) {
          internalId_.betaStarClassic_ += tkpt;
        }
        if (fabs(dZ0) < 0.2) {
          internalId_.beta_ += tkpt;
        } else if (fabs(dZ_tmp) < 0.2) {
          internalId_.betaStar_ += tkpt;
        }
      }
    }
 
    // trailing candidate
    if (lTrail == nullptr || candPt < lTrail->pt()) {
      lTrail = icand;
    }
  }
 
  // // Finalize all variables
  assert(!(lLead == nullptr));
 
  if (lSecond == nullptr) {
    lSecond = lTrail;
  }
  if (lLeadNeut == nullptr) {
    lLeadNeut = lTrail;
  }
  if (lLeadEm == nullptr) {
    lLeadEm = lTrail;
  }
  if (lLeadCh == nullptr) {
    lLeadCh = lTrail;
  }
 
  if (patjet != nullptr) {  // to enable running on MiniAOD slimmedJets
    internalId_.nCharged_ = patjet->chargedMultiplicity();
    internalId_.nNeutrals_ = patjet->neutralMultiplicity();
    internalId_.chgEMfrac_ = patjet->chargedEmEnergy() / jet->energy();
    internalId_.neuEMfrac_ = patjet->neutralEmEnergy() / jet->energy();
    internalId_.chgHadrfrac_ = patjet->chargedHadronEnergy() / jet->energy();
    internalId_.neuHadrfrac_ = patjet->neutralHadronEnergy() / jet->energy();
    if (usePuppi)
      internalId_.nNeutrals_ = multNeut;
  } else {
    internalId_.nCharged_ = pfjet->chargedMultiplicity();
    internalId_.nNeutrals_ = pfjet->neutralMultiplicity();
    internalId_.chgEMfrac_ = pfjet->chargedEmEnergy() / jet->energy();
    internalId_.neuEMfrac_ = pfjet->neutralEmEnergy() / jet->energy();
    internalId_.chgHadrfrac_ = pfjet->chargedHadronEnergy() / jet->energy();
    internalId_.neuHadrfrac_ = pfjet->neutralHadronEnergy() / jet->energy();
  }
  internalId_.nParticles_ = jet->nConstituents();
 
  float sumW2(0.0);
  float sum_deta(0.0), sum_dphi(0.0);
  float ave_deta(0.0), ave_dphi(0.0);
  for (size_t j = 0; j < jet->numberOfDaughters(); j++) {
    const auto& part = jet->daughterPtr(j);
    if (!(part.isAvailable() && part.isNonnull())) {
      continue;
    }
 
    float partPuppiWeight = 1.0;
    if (usePuppi) {
      const pat::PackedCandidate* partpack = dynamic_cast<const pat::PackedCandidate*>(part.get());
      if (partpack != nullptr)
        partPuppiWeight = partpack->puppiWeight();
    }
 
    float weight = (part->pt()) * partPuppiWeight;
    float weight2 = weight * weight;
    sumW2 += weight2;
    float deta = part->eta() - jet->eta();
    float dphi = reco::deltaPhi(*part, *jet);
    sum_deta += deta * weight2;
    sum_dphi += dphi * weight2;
    if (sumW2 > 0) {
      ave_deta = sum_deta / sumW2;
      ave_dphi = sum_dphi / sumW2;
    }
  }
 
  float ddetaR_sum(0.0), ddphiR_sum(0.0), pull_tmp(0.0);
  for (size_t i = 0; i < jet->numberOfDaughters(); i++) {
    const auto& part = jet->daughterPtr(i);
    if (!(part.isAvailable() && part.isNonnull())) {
      continue;
    }
 
    float partPuppiWeight = 1.0;
    if (usePuppi) {
      const pat::PackedCandidate* partpack = dynamic_cast<const pat::PackedCandidate*>(part.get());
      if (partpack != nullptr)
        partPuppiWeight = partpack->puppiWeight();
    }
 
    float weight = partPuppiWeight * (part->pt()) * partPuppiWeight * (part->pt());
    float deta = part->eta() - jet->eta();
    float dphi = reco::deltaPhi(*part, *jet);
    float ddeta, ddphi, ddR;
    ddeta = deta - ave_deta;
    ddphi = dphi - ave_dphi;
    ddR = sqrt(ddeta * ddeta + ddphi * ddphi);
    ddetaR_sum += ddR * ddeta * weight;
    ddphiR_sum += ddR * ddphi * weight;
  }
  if (sumW2 > 0) {
    float ddetaR_ave = ddetaR_sum / sumW2;
    float ddphiR_ave = ddphiR_sum / sumW2;
    pull_tmp = sqrt(ddetaR_ave * ddetaR_ave + ddphiR_ave * ddphiR_ave);
  }
  internalId_.pull_ = pull_tmp;
 
  setPtEtaPhi(*lLead, internalId_.leadPt_, internalId_.leadEta_, internalId_.leadPhi_);
  setPtEtaPhi(*lSecond, internalId_.secondPt_, internalId_.secondEta_, internalId_.secondPhi_);
  setPtEtaPhi(*lLeadNeut, internalId_.leadNeutPt_, internalId_.leadNeutEta_, internalId_.leadNeutPhi_);
  setPtEtaPhi(*lLeadEm, internalId_.leadEmPt_, internalId_.leadEmEta_, internalId_.leadEmPhi_);
  setPtEtaPhi(*lLeadCh, internalId_.leadChPt_, internalId_.leadChEta_, internalId_.leadChPhi_);
 
  std::sort(frac.begin(), frac.end(), std::greater<float>());
  std::sort(fracCh.begin(), fracCh.end(), std::greater<float>());
  std::sort(fracEm.begin(), fracEm.end(), std::greater<float>());
  std::sort(fracNeut.begin(), fracNeut.end(), std::greater<float>());
  assign(frac, internalId_.leadFrac_, internalId_.secondFrac_, internalId_.thirdFrac_, internalId_.fourthFrac_);
  assign(
      fracCh, internalId_.leadChFrac_, internalId_.secondChFrac_, internalId_.thirdChFrac_, internalId_.fourthChFrac_);
  assign(
      fracEm, internalId_.leadEmFrac_, internalId_.secondEmFrac_, internalId_.thirdEmFrac_, internalId_.fourthEmFrac_);
  assign(fracNeut,
         internalId_.leadNeutFrac_,
         internalId_.secondNeutFrac_,
         internalId_.thirdNeutFrac_,
         internalId_.fourthNeutFrac_);
 
  covMatrix(0, 0) /= sumPt2;
  covMatrix(0, 1) /= sumPt2;
  covMatrix(1, 1) /= sumPt2;
  covMatrix(1, 0) = covMatrix(0, 1);
  internalId_.etaW_ = sqrt(covMatrix(0, 0));
  internalId_.phiW_ = sqrt(covMatrix(1, 1));
  internalId_.jetW_ = 0.5 * (internalId_.etaW_ + internalId_.phiW_);
  TVectorD eigVals(2);
  eigVals = TMatrixDSymEigen(covMatrix).GetEigenValues();
  internalId_.majW_ = sqrt(std::abs(eigVals(0)));
  internalId_.minW_ = sqrt(std::abs(eigVals(1)));
  if (internalId_.majW_ < internalId_.minW_) {
    std::swap(internalId_.majW_, internalId_.minW_);
  }
 
  internalId_.dRLeadCent_ = reco::deltaR(*jet, *lLead);
  if (lSecond == nullptr) {
    internalId_.dRLead2nd_ = reco::deltaR(*jet, *lSecond);
  }
  internalId_.dRMean_ /= jetPt;
  internalId_.dRMeanNeut_ /= jetPt;
  internalId_.dRMeanEm_ /= jetPt;
  internalId_.dRMeanCh_ /= jetPt;
  internalId_.dR2Mean_ /= sumPt2;
 
  for (size_t ic = 0; ic < ncones; ++ic) {
    *coneFracs[ic] /= jetPt;
    *coneEmFracs[ic] /= jetPt;
    *coneNeutFracs[ic] /= jetPt;
    *coneChFracs[ic] /= jetPt;
  }
  //http://jets.physics.harvard.edu/qvg/
  double ptMean = sumPt / internalId_.nParticles_;
  double ptRMS = 0;
  for (unsigned int i0 = 0; i0 < frac.size(); i0++) {
    ptRMS += (frac[i0] - ptMean) * (frac[i0] - ptMean);
  }
  ptRMS /= internalId_.nParticles_;
  ptRMS = sqrt(ptRMS);
 
  internalId_.ptMean_ = ptMean;
  internalId_.ptRMS_ = ptRMS / jetPt;
  internalId_.pt2A_ = sqrt(internalId_.ptD_ / internalId_.nParticles_) / jetPt;
  internalId_.ptD_ = sqrt(internalId_.ptD_) / sumPt;
  internalId_.ptDCh_ = sqrt(internalId_.ptDCh_) / sumPtCh;
  internalId_.ptDNe_ = sqrt(internalId_.ptDNe_) / sumPtNe;
  internalId_.sumPt_ = sumPt;
  internalId_.sumChPt_ = sumPtCh;
  internalId_.sumNePt_ = sumPtNe;
 
  internalId_.jetR_ = lLead->pt() / sumPt;
  internalId_.jetRchg_ = lLeadCh->pt() / sumPt;
  internalId_.dRMatch_ = dRmin;
 
  if (sumTkPt != 0.) {
    internalId_.beta_ /= sumTkPt;
    internalId_.betaStar_ /= sumTkPt;
    internalId_.betaClassic_ /= sumTkPt;
    internalId_.betaStarClassic_ /= sumTkPt;
  } else {
    assert(internalId_.beta_ == 0. && internalId_.betaStar_ == 0. && internalId_.betaClassic_ == 0. &&
           internalId_.betaStarClassic_ == 0.);
  }
 
  if (cache_->runMvas()) {
    runMva();
  }
 
  return PileupJetIdentifier(internalId_);
}

References funct::abs(), cms::cuda::assert(), assign(), reco::Muon::bestTrack(), reco::Candidate::bestTrack(), StoredPileupJetIdentifier::beta_, StoredPileupJetIdentifier::betaClassic_, StoredPileupJetIdentifier::betaStar_, StoredPileupJetIdentifier::betaStarClassic_, cache_, reco::Candidate::charge(), reco::PFJet::chargedEmEnergy(), pat::Jet::chargedEmEnergy(), reco::PFJet::chargedHadronEnergy(), pat::Jet::chargedHadronEnergy(), reco::PFJet::chargedMultiplicity(), pat::Jet::chargedMultiplicity(), PileupJetIdentifier::chFrac01_, PileupJetIdentifier::chFrac02_, PileupJetIdentifier::chFrac03_, PileupJetIdentifier::chFrac04_, PileupJetIdentifier::chFrac05_, PileupJetIdentifier::chFrac06_, PileupJetIdentifier::chFrac07_, PileupJetIdentifier::chgEMfrac_, PileupJetIdentifier::chgHadrfrac_, pat::Jet::correctedJet(), PileupJetIdentifier::d0_, reco::deltaPhi(), reco::deltaR(), StoredPileupJetIdentifier::dR2Mean_, PileupJetIdentifier::dRLead2nd_, PileupJetIdentifier::dRLeadCent_, StoredPileupJetIdentifier::dRMatch_, StoredPileupJetIdentifier::dRMean_, PileupJetIdentifier::dRMeanCh_, PileupJetIdentifier::dRMeanEm_, PileupJetIdentifier::dRMeanNeut_, reco::TrackBase::dxy(), pat::PackedCandidate::dxy(), reco::TrackBase::dz(), pat::PackedCandidate::dz(), StoredPileupJetIdentifier::dZ_, PileupJetIdentifier::emFrac01_, PileupJetIdentifier::emFrac02_, PileupJetIdentifier::emFrac03_, PileupJetIdentifier::emFrac04_, PileupJetIdentifier::emFrac05_, PileupJetIdentifier::emFrac06_, PileupJetIdentifier::emFrac07_, reco::Candidate::eta(), PileupJetIdentifier::etaW_, PileupJetIdentifier::fourthChFrac_, PileupJetIdentifier::fourthEmFrac_, PileupJetIdentifier::fourthFrac_, PileupJetIdentifier::fourthNeutFrac_, cropTnPTrees::frac, StoredPileupJetIdentifier::frac01_, StoredPileupJetIdentifier::frac02_, StoredPileupJetIdentifier::frac03_, StoredPileupJetIdentifier::frac04_, StoredPileupJetIdentifier::frac05_, StoredPileupJetIdentifier::frac06_, StoredPileupJetIdentifier::frac07_, pat::PackedCandidate::fromPV(), edm::Ptr< T >::get(), edm::Ref< C, T, F >::get(), reco::PFCandidate::gsfTrackRef(), mps_fire::i, internalId_, reco::Vertex::isFake(), edm::Ref< C, T, F >::isNonnull(), dqmiolumiharvest::j, jetMETDQMOfflineSource_cff::jec, metsig::jet, StoredPileupJetIdentifier::jetEta_, PileupJetIdentifier::jetM_, PileupJetIdentifier::jetPhi_, reco::btau::jetPt, StoredPileupJetIdentifier::jetPt_, StoredPileupJetIdentifier::jetR_, StoredPileupJetIdentifier::jetRchg_, PileupJetIdentifier::jetW_, PileupJetIdentifier::leadChEta_, PileupJetIdentifier::leadChFrac_, PileupJetIdentifier::leadChPhi_, PileupJetIdentifier::leadChPt_, PileupJetIdentifier::leadEmEta_, PileupJetIdentifier::leadEmFrac_, PileupJetIdentifier::leadEmPhi_, PileupJetIdentifier::leadEmPt_, PileupJetIdentifier::leadEta_, PileupJetIdentifier::leadFrac_, PileupJetIdentifier::leadNeutEta_, PileupJetIdentifier::leadNeutFrac_, PileupJetIdentifier::leadNeutPhi_, PileupJetIdentifier::leadNeutPt_, PileupJetIdentifier::leadPhi_, PileupJetIdentifier::leadPt_, cuda_std::lower_bound(), StoredPileupJetIdentifier::majW_, min(), StoredPileupJetIdentifier::minW_, reco::PFCandidate::muonRef(), StoredPileupJetIdentifier::nCharged_, reco::Vertex::ndof(), PileupJetIdentifier::neuEMfrac_, PileupJetIdentifier::neuHadrfrac_, PileupJetIdentifier::neutFrac01_, PileupJetIdentifier::neutFrac02_, PileupJetIdentifier::neutFrac03_, PileupJetIdentifier::neutFrac04_, PileupJetIdentifier::neutFrac05_, PileupJetIdentifier::neutFrac06_, PileupJetIdentifier::neutFrac07_, reco::PFJet::neutralEmEnergy(), pat::Jet::neutralEmEnergy(), reco::PFJet::neutralHadronEnergy(), pat::Jet::neutralHadronEnergy(), reco::PFJet::neutralMultiplicity(), pat::Jet::neutralMultiplicity(), StoredPileupJetIdentifier::nNeutrals_, StoredPileupJetIdentifier::nParticles_, StoredPileupJetIdentifier::nvtx_, reco::Candidate::pdgId(), PileupJetIdentifier::phiW_, reco::Vertex::position(), DiDispStaMuonMonitor_cfi::pt, reco::Candidate::pt(), reco::LeafCandidate::pt(), PileupJetIdentifier::pt2A_, StoredPileupJetIdentifier::ptD_, PileupJetIdentifier::ptDCh_, PileupJetIdentifier::ptDNe_, PileupJetIdentifier::ptMean_, PileupJetIdentifier::ptRMS_, StoredPileupJetIdentifier::pull_, pat::PackedCandidate::puppiWeight(), pat::PackedCandidate::PVUsedInFit, alignCSCRings::r, resetVariables(), rho, StoredPileupJetIdentifier::rho_, runMva(), PileupJetIdAlgo::AlgoGBRForestsAndConstants::runMvas(), PileupJetIdentifier::secondChFrac_, PileupJetIdentifier::secondEmFrac_, PileupJetIdentifier::secondEta_, PileupJetIdentifier::secondFrac_, PileupJetIdentifier::secondNeutFrac_, PileupJetIdentifier::secondPhi_, PileupJetIdentifier::secondPt_, setPtEtaPhi(), mathSSE::sqrt(), PileupJetIdentifier::sumChPt_, PileupJetIdentifier::sumNePt_, TtFullHadEvtBuilder_cfi::sumPt, PileupJetIdentifier::sumPt_, std::swap(), PileupJetIdentifier::thirdChFrac_, PileupJetIdentifier::thirdEmFrac_, PileupJetIdentifier::thirdFrac_, PileupJetIdentifier::thirdNeutFrac_, reco::PFCandidate::trackRef(), PileupJetID_cfi::usePuppi, badGlobalMuonTaggersAOD_cff::vtx, and mps_merge::weight.

Referenced by PileupJetIdProducer::produce().

computeMva()

PileupJetIdentifier PileupJetIdAlgo::computeMva

(

)

Definition at line 245 of file PileupJetIdAlgo.cc.

                                                {
  runMva();
  return PileupJetIdentifier(internalId_);
}

References internalId_, and runMva().

Referenced by PileupJetIdProducer::produce().

dumpVariables()

std::string PileupJetIdAlgo::dumpVariables

(

)

const

Definition at line 713 of file PileupJetIdAlgo.cc.

                                               {
  std::stringstream out;
  for (variables_list_t::const_iterator it = variables_.begin(); it != variables_.end(); ++it) {
    out << std::setw(15) << it->first << std::setw(3) << "=" << std::setw(5) << *it->second.first << " ("
        << std::setw(5) << it->second.second << ")" << std::endl;
  }
  return out.str();
}

References MillePedeFileConverter_cfg::out, and variables_.

getJetIdKey()

std::pair< int, int > PileupJetIdAlgo::getJetIdKey	(	float	jetPt,
		float	jetEta
	)

Definition at line 189 of file PileupJetIdAlgo.cc.

                                                                        {
  int ptId = 0;
  if (jetPt >= 10 && jetPt < 20)
    ptId = 1;
  if (jetPt >= 20 && jetPt < 30)
    ptId = 2;
  if (jetPt >= 30)
    ptId = 3;
 
  int etaId = 0;
  if (std::abs(jetEta) >= 2.5 && std::abs(jetEta) < 2.75)
    etaId = 1;
  if (std::abs(jetEta) >= 2.75 && std::abs(jetEta) < 3.0)
    etaId = 2;
  if (std::abs(jetEta) >= 3.0 && std::abs(jetEta) < 5.0)
    etaId = 3;
 
  return std::pair<int, int>(ptId, etaId);
}

References funct::abs(), reco::btau::jetEta, and reco::btau::jetPt.

Referenced by computeCutIDflag(), and computeIDflag().

getMVAval()

float PileupJetIdAlgo::getMVAval	(	const std::vector< std::string > &	varList,
		const std::unique_ptr< const GBRForest > &	reader
	)

Definition at line 150 of file PileupJetIdAlgo.cc.

                                                                               {
  std::vector<float> vars;
  for (std::vector<std::string>::const_iterator it = varList.begin(); it != varList.end(); ++it) {
    std::pair<float*, float> var = variables_.at(*it);
    vars.push_back(*var.first);
  }
  return reader->GetClassifier(vars.data());
}

References DQM::reader, trigObjTnPSource_cfi::var, and variables_.

Referenced by runMva().

getVariables()

const variables_list_t& PileupJetIdAlgo::getVariables ( ) const

inline

const PileupJetIdentifier::variables_list_t & getVariables() const { return variables_; };

Definition at line 49 of file PileupJetIdAlgo.h.

{ return variables_; };

References variables_.

initVariables()

void PileupJetIdAlgo::initVariables ( )

protected

Definition at line 736 of file PileupJetIdAlgo.cc.

                                    {
  internalId_.idFlag_ = 0;
  INIT_VARIABLE(mva, "", -100.);
  //INIT_VARIABLE(jetPt      , "jspt_1", 0.);
  //INIT_VARIABLE(jetEta     , "jseta_1", large_val);
  INIT_VARIABLE(jetPt, "", 0.);
  INIT_VARIABLE(jetEta, "", large_val);
  INIT_VARIABLE(jetPhi, "jsphi_1", large_val);
  INIT_VARIABLE(jetM, "jm_1", 0.);
 
  INIT_VARIABLE(nCharged, "", 0.);
  INIT_VARIABLE(nNeutrals, "", 0.);
 
  INIT_VARIABLE(chgEMfrac, "", 0.);
  INIT_VARIABLE(neuEMfrac, "", 0.);
  INIT_VARIABLE(chgHadrfrac, "", 0.);
  INIT_VARIABLE(neuHadrfrac, "", 0.);
 
  INIT_VARIABLE(d0, "jd0_1", -1000.);
  INIT_VARIABLE(dZ, "jdZ_1", -1000.);
  //INIT_VARIABLE(nParticles , "npart_1"  , 0.);
  INIT_VARIABLE(nParticles, "", 0.);
 
  INIT_VARIABLE(leadPt, "lpt_1", 0.);
  INIT_VARIABLE(leadEta, "leta_1", large_val);
  INIT_VARIABLE(leadPhi, "lphi_1", large_val);
  INIT_VARIABLE(secondPt, "spt_1", 0.);
  INIT_VARIABLE(secondEta, "seta_1", large_val);
  INIT_VARIABLE(secondPhi, "sphi_1", large_val);
  INIT_VARIABLE(leadNeutPt, "lnept_1", 0.);
  INIT_VARIABLE(leadNeutEta, "lneeta_1", large_val);
  INIT_VARIABLE(leadNeutPhi, "lnephi_1", large_val);
  INIT_VARIABLE(leadEmPt, "lempt_1", 0.);
  INIT_VARIABLE(leadEmEta, "lemeta_1", large_val);
  INIT_VARIABLE(leadEmPhi, "lemphi_1", large_val);
  INIT_VARIABLE(leadChPt, "lchpt_1", 0.);
  INIT_VARIABLE(leadChEta, "lcheta_1", large_val);
  INIT_VARIABLE(leadChPhi, "lchphi_1", large_val);
  INIT_VARIABLE(leadFrac, "lLfr_1", 0.);
 
  INIT_VARIABLE(dRLeadCent, "drlc_1", 0.);
  INIT_VARIABLE(dRLead2nd, "drls_1", 0.);
  INIT_VARIABLE(dRMean, "drm_1", 0.);
  INIT_VARIABLE(dRMean, "", 0.);
  INIT_VARIABLE(pull, "", 0.);
  INIT_VARIABLE(dRMeanNeut, "drmne_1", 0.);
  INIT_VARIABLE(dRMeanEm, "drem_1", 0.);
  INIT_VARIABLE(dRMeanCh, "drch_1", 0.);
  INIT_VARIABLE(dR2Mean, "", 0.);
 
  INIT_VARIABLE(ptD, "", 0.);
  INIT_VARIABLE(ptMean, "", 0.);
  INIT_VARIABLE(ptRMS, "", 0.);
  INIT_VARIABLE(pt2A, "", 0.);
  INIT_VARIABLE(ptDCh, "", 0.);
  INIT_VARIABLE(ptDNe, "", 0.);
  INIT_VARIABLE(sumPt, "", 0.);
  INIT_VARIABLE(sumChPt, "", 0.);
  INIT_VARIABLE(sumNePt, "", 0.);
 
  INIT_VARIABLE(secondFrac, "", 0.);
  INIT_VARIABLE(thirdFrac, "", 0.);
  INIT_VARIABLE(fourthFrac, "", 0.);
 
  INIT_VARIABLE(leadChFrac, "", 0.);
  INIT_VARIABLE(secondChFrac, "", 0.);
  INIT_VARIABLE(thirdChFrac, "", 0.);
  INIT_VARIABLE(fourthChFrac, "", 0.);
 
  INIT_VARIABLE(leadNeutFrac, "", 0.);
  INIT_VARIABLE(secondNeutFrac, "", 0.);
  INIT_VARIABLE(thirdNeutFrac, "", 0.);
  INIT_VARIABLE(fourthNeutFrac, "", 0.);
 
  INIT_VARIABLE(leadEmFrac, "", 0.);
  INIT_VARIABLE(secondEmFrac, "", 0.);
  INIT_VARIABLE(thirdEmFrac, "", 0.);
  INIT_VARIABLE(fourthEmFrac, "", 0.);
 
  INIT_VARIABLE(jetW, "", 1.);
  INIT_VARIABLE(etaW, "", 1.);
  INIT_VARIABLE(phiW, "", 1.);
 
  INIT_VARIABLE(majW, "", 1.);
  INIT_VARIABLE(minW, "", 1.);
 
  INIT_VARIABLE(frac01, "", 0.);
  INIT_VARIABLE(frac02, "", 0.);
  INIT_VARIABLE(frac03, "", 0.);
  INIT_VARIABLE(frac04, "", 0.);
  INIT_VARIABLE(frac05, "", 0.);
  INIT_VARIABLE(frac06, "", 0.);
  INIT_VARIABLE(frac07, "", 0.);
 
  INIT_VARIABLE(chFrac01, "", 0.);
  INIT_VARIABLE(chFrac02, "", 0.);
  INIT_VARIABLE(chFrac03, "", 0.);
  INIT_VARIABLE(chFrac04, "", 0.);
  INIT_VARIABLE(chFrac05, "", 0.);
  INIT_VARIABLE(chFrac06, "", 0.);
  INIT_VARIABLE(chFrac07, "", 0.);
 
  INIT_VARIABLE(neutFrac01, "", 0.);
  INIT_VARIABLE(neutFrac02, "", 0.);
  INIT_VARIABLE(neutFrac03, "", 0.);
  INIT_VARIABLE(neutFrac04, "", 0.);
  INIT_VARIABLE(neutFrac05, "", 0.);
  INIT_VARIABLE(neutFrac06, "", 0.);
  INIT_VARIABLE(neutFrac07, "", 0.);
 
  INIT_VARIABLE(emFrac01, "", 0.);
  INIT_VARIABLE(emFrac02, "", 0.);
  INIT_VARIABLE(emFrac03, "", 0.);
  INIT_VARIABLE(emFrac04, "", 0.);
  INIT_VARIABLE(emFrac05, "", 0.);
  INIT_VARIABLE(emFrac06, "", 0.);
  INIT_VARIABLE(emFrac07, "", 0.);
 
  INIT_VARIABLE(beta, "", 0.);
  INIT_VARIABLE(betaStar, "", 0.);
  INIT_VARIABLE(betaClassic, "", 0.);
  INIT_VARIABLE(betaStarClassic, "", 0.);
 
  INIT_VARIABLE(nvtx, "", 0.);
  INIT_VARIABLE(rho, "", 0.);
  INIT_VARIABLE(nTrueInt, "", 0.);
 
  INIT_VARIABLE(jetR, "", 0.);
  INIT_VARIABLE(jetRchg, "", 0.);
  INIT_VARIABLE(dRMatch, "", 0.);
}

References zMuMuMuonUserData::beta, BeamSpotFakeParameters_cfi::betaStar, d0, METSignificanceParams_cfi::dRMatch, PileupJetIdentifier::idFlag_, INIT_VARIABLE, internalId_, reco::btau::jetEta, reco::btau::jetPhi, reco::btau::jetPt, LHEJetFilter_cfi::jetR, large_val, beam_dqm_sourceclient-live_cfg::mva, HLT_2018_cff::nCharged, jets_cff::ptD, rho, and TtFullHadEvtBuilder_cfi::sumPt.

Referenced by PileupJetIdAlgo().

method()

const std::string PileupJetIdAlgo::method ( ) const

inline

Definition at line 37 of file PileupJetIdAlgo.h.

{ return cache_->tmvaMethod(); }

References cache_, and PileupJetIdAlgo::AlgoGBRForestsAndConstants::tmvaMethod().

resetVariables()

void PileupJetIdAlgo::resetVariables ( )

protected

Definition at line 723 of file PileupJetIdAlgo.cc.

                                     {
  internalId_.idFlag_ = 0;
  for (variables_list_t::iterator it = variables_.begin(); it != variables_.end(); ++it) {
    *it->second.first = it->second.second;
  }
}

References PileupJetIdentifier::idFlag_, internalId_, and variables_.

Referenced by computeIdVariables().

runMva()

void PileupJetIdAlgo::runMva ( )

protected

Definition at line 160 of file PileupJetIdAlgo.cc.

                             {
  if (cache_->cutBased()) {
    internalId_.idFlag_ = computeCutIDflag(
        internalId_.betaStarClassic_, internalId_.dR2Mean_, internalId_.nvtx_, internalId_.jetPt_, internalId_.jetEta_);
  } else {
    if (std::abs(internalId_.jetEta_) >= 5.0) {
      internalId_.mva_ = -2.;
    } else {
      if (cache_->etaBinnedWeights()) {
        if (std::abs(internalId_.jetEta_) > cache_->jEtaMax().at(cache_->nEtaBins() - 1)) {
          internalId_.mva_ = -2.;
        } else {
          for (int v = 0; v < cache_->nEtaBins(); v++) {
            if (std::abs(internalId_.jetEta_) >= cache_->jEtaMin().at(v) &&
                std::abs(internalId_.jetEta_) < cache_->jEtaMax().at(v)) {
              internalId_.mva_ = getMVAval(cache_->tmvaEtaVariables().at(v), cache_->etaReader().at(v));
              break;
            }
          }
        }
      } else {
        internalId_.mva_ = getMVAval(cache_->tmvaVariables(), cache_->reader());
      }
    }
    internalId_.idFlag_ = computeIDflag(internalId_.mva_, internalId_.jetPt_, internalId_.jetEta_);
  }
}

References funct::abs(), StoredPileupJetIdentifier::betaStarClassic_, cache_, computeCutIDflag(), computeIDflag(), PileupJetIdAlgo::AlgoGBRForestsAndConstants::cutBased(), StoredPileupJetIdentifier::dR2Mean_, PileupJetIdAlgo::AlgoGBRForestsAndConstants::etaBinnedWeights(), PileupJetIdAlgo::AlgoGBRForestsAndConstants::etaReader(), getMVAval(), PileupJetIdentifier::idFlag_, internalId_, PileupJetIdAlgo::AlgoGBRForestsAndConstants::jEtaMax(), PileupJetIdAlgo::AlgoGBRForestsAndConstants::jEtaMin(), StoredPileupJetIdentifier::jetEta_, StoredPileupJetIdentifier::jetPt_, PileupJetIdentifier::mva_, PileupJetIdAlgo::AlgoGBRForestsAndConstants::nEtaBins(), StoredPileupJetIdentifier::nvtx_, PileupJetIdAlgo::AlgoGBRForestsAndConstants::reader(), PileupJetIdAlgo::AlgoGBRForestsAndConstants::tmvaEtaVariables(), PileupJetIdAlgo::AlgoGBRForestsAndConstants::tmvaVariables(), and findQualityFiles::v.

Referenced by computeIdVariables(), and computeMva().

set()

void PileupJetIdAlgo::set

(

const PileupJetIdentifier &

id

)

Definition at line 146 of file PileupJetIdAlgo.cc.

{ internalId_ = id; }

References triggerObjects_cff::id, and internalId_.

Referenced by PileupJetIdProducer::produce().

Member Data Documentation

cache_

AlgoGBRForestsAndConstants const* PileupJetIdAlgo::cache_

protected

Definition at line 106 of file PileupJetIdAlgo.h.

Referenced by computeIDflag(), computeIdVariables(), method(), and runMva().

internalId_

PileupJetIdentifier PileupJetIdAlgo::internalId_

protected

Definition at line 104 of file PileupJetIdAlgo.h.

Referenced by computeIdVariables(), computeMva(), initVariables(), resetVariables(), runMva(), and set().

variables_

variables_list_t PileupJetIdAlgo::variables_

protected

Definition at line 105 of file PileupJetIdAlgo.h.

Referenced by dumpVariables(), getMVAval(), getVariables(), and resetVariables().