FFTGenericScaleCalculator Class Reference

#include <FFTGenericScaleCalculator.h>

Inheritance diagram for FFTGenericScaleCalculator:

Public Member Functions
	FFTGenericScaleCalculator (const edm::ParameterSet &ps)
void	mapFFTJet (const reco::Jet &jet, const reco::FFTJet< float > &fftJet, const math::XYZTLorentzVector &current, double *buf, unsigned dim) const override
	~FFTGenericScaleCalculator () override
Public Member Functions inherited from AbsFFTSpecificScaleCalculator
virtual	~AbsFFTSpecificScaleCalculator ()

Private Member Functions
double	f_safeLog (const double x) const

Private Attributes
int	m_aveConstituentPt
int	m_averageWidth
int	m_chargedEmEnergyFraction
int	m_chargedHadronEnergyFraction
int	m_chargedHadronMultiplicity
int	m_chargedMuEnergyFraction
int	m_chargedMultiplicity
int	m_clusterRadius
int	m_clusterSeparation
int	m_constituentEtaPhiSpread
int	m_constituentPtDistribution
int	m_convergenceDistance
int	m_dRFromJet
int	m_driftSpeed
int	m_electronEnergyFraction
int	m_electronMultiplicity
int	m_EmEnergyFraction
int	m_energy
int	m_eta
int	m_etaPhiCorr
int	m_etaWidth
int	m_etSum
std::vector< double >	m_factors
int	m_fuzziness
int	m_gamma
int	m_HessianS2
int	m_HessianS4
int	m_HessianS6
int	m_HFEMEnergyFraction
int	m_HFEMMultiplicity
int	m_HFHadronEnergyFraction
int	m_HFHadronMultiplicity
int	m_LaplacianS1
int	m_LaplacianS2
int	m_LaplacianS3
int	m_lifetime
int	m_logAveConstituentPt
int	m_logEnergy
int	m_logGamma
int	m_logMagnitude
int	m_LogMagS1
int	m_LogMagS2
int	m_logMass
int	m_logPt
int	m_logScale
int	m_magnitude
int	m_magS1
int	m_magS2
int	m_magSpeed
int	m_mass
int	m_membershipFactor
int	m_mergeTime
double	m_minLog
int	m_muonEnergyFraction
int	m_muonMultiplicity
int	m_ncells
int	m_nConstituents
int	m_nearestNeighborDistance
int	m_neutralEmEnergyFraction
int	m_neutralHadronEnergyFraction
int	m_neutralHadronMultiplicity
int	m_neutralMultiplicity
int	m_phi
int	m_phiWidth
int	m_photonEnergyFraction
int	m_photonMultiplicity
int	m_pileup
int	m_pt
int	m_recoScale
int	m_recoScaleRatio
int	m_scale
int	m_splitTime
int	m_widthRatio

Detailed Description

Definition at line 13 of file FFTGenericScaleCalculator.h.

Constructor & Destructor Documentation

FFTGenericScaleCalculator()

FFTGenericScaleCalculator::FFTGenericScaleCalculator

(

const edm::ParameterSet &

ps

)

Definition at line 29 of file FFTGenericScaleCalculator.cc.

References reco::btau::chargedHadronEnergyFraction, reco::btau::chargedHadronMultiplicity, check_param, fftjetproducer_cfi::convergenceDistance, reco::btau::electronEnergyFraction, reco::btau::electronMultiplicity, hcalRecHitTable_cff::energy, PVValHelper::eta, electrons_cff::etaWidth, Exception, CustomPhysics_cfi::gamma, run3scouting_cff::HFEMMultiplicity, run3scouting_cff::HFHadronMultiplicity, mps_fire::i, m_factors, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, EgHLTOffHistBins_cfi::mass, reco::btau::muonEnergyFraction, reco::btau::muonMultiplicity, custom_jme_cff::nConstituents, reco::btau::neutralHadronEnergyFraction, reco::btau::neutralHadronMultiplicity, phi, electrons_cff::phiWidth, reco::btau::photonEnergyFraction, reco::btau::photonMultiplicity, mixOne_premix_on_sim_cfi::pileup, DiDispStaMuonMonitor_cfi::pt, and pfClustersFromCombinedCaloHF_cfi::scale.

    : m_factors(ps.getParameter<std::vector<double> >("factors")),
      m_minLog(ps.getUntrackedParameter<double>("minLog", -800.0)),
      int_param(eta),
      int_param(phi),
      int_param(pt),
      int_param(logPt),
      int_param(mass),
      int_param(logMass),
      int_param(energy),
      int_param(logEnergy),
      int_param(gamma),
      int_param(logGamma),
      int_param(pileup),
      int_param(ncells),
      int_param(etSum),
      int_param(etaWidth),
      int_param(phiWidth),
      int_param(averageWidth),
      int_param(widthRatio),
      int_param(etaPhiCorr),
      int_param(fuzziness),
      int_param(convergenceDistance),
      int_param(recoScale),
      int_param(recoScaleRatio),
      int_param(membershipFactor),
      int_param(magnitude),
      int_param(logMagnitude),
      int_param(magS1),
      int_param(LogMagS1),
      int_param(magS2),
      int_param(LogMagS2),
      int_param(driftSpeed),
      int_param(magSpeed),
      int_param(lifetime),
      int_param(splitTime),
      int_param(mergeTime),
      int_param(scale),
      int_param(logScale),
      int_param(nearestNeighborDistance),
      int_param(clusterRadius),
      int_param(clusterSeparation),
      int_param(dRFromJet),
      int_param(LaplacianS1),
      int_param(LaplacianS2),
      int_param(LaplacianS3),
      int_param(HessianS2),
      int_param(HessianS4),
      int_param(HessianS6),
      int_param(nConstituents),
      int_param(aveConstituentPt),
      int_param(logAveConstituentPt),
      int_param(constituentPtDistribution),
      int_param(constituentEtaPhiSpread),
      int_param(chargedHadronEnergyFraction),
      int_param(neutralHadronEnergyFraction),
      int_param(photonEnergyFraction),
      int_param(electronEnergyFraction),
      int_param(muonEnergyFraction),
      int_param(HFHadronEnergyFraction),
      int_param(HFEMEnergyFraction),
      int_param(chargedHadronMultiplicity),
      int_param(neutralHadronMultiplicity),
      int_param(photonMultiplicity),
      int_param(electronMultiplicity),
      int_param(muonMultiplicity),
      int_param(HFHadronMultiplicity),
      int_param(HFEMMultiplicity),
      int_param(chargedEmEnergyFraction),
      int_param(chargedMuEnergyFraction),
      int_param(neutralEmEnergyFraction),
      int_param(EmEnergyFraction),
      int_param(chargedMultiplicity),
      int_param(neutralMultiplicity) {
  const int nFactors = m_factors.size();
  std::vector<int> mask(nFactors, 0);
  int dim = 0;

  check_param(eta);
  check_param(phi);
  check_param(pt);
  check_param(logPt);
  check_param(mass);
  check_param(logMass);
  check_param(energy);
  check_param(logEnergy);
  check_param(gamma);
  check_param(logGamma);
  check_param(pileup);
  check_param(ncells);
  check_param(etSum);
  check_param(etaWidth);
  check_param(phiWidth);
  check_param(averageWidth);
  check_param(widthRatio);
  check_param(etaPhiCorr);
  check_param(fuzziness);
  check_param(convergenceDistance);
  check_param(recoScale);
  check_param(recoScaleRatio);
  check_param(membershipFactor);
  check_param(magnitude);
  check_param(logMagnitude);
  check_param(magS1);
  check_param(LogMagS1);
  check_param(magS2);
  check_param(LogMagS2);
  check_param(driftSpeed);
  check_param(magSpeed);
  check_param(lifetime);
  check_param(splitTime);
  check_param(mergeTime);
  check_param(scale);
  check_param(logScale);
  check_param(nearestNeighborDistance);
  check_param(clusterRadius);
  check_param(clusterSeparation);
  check_param(dRFromJet);
  check_param(LaplacianS1);
  check_param(LaplacianS2);
  check_param(LaplacianS3);
  check_param(HessianS2);
  check_param(HessianS4);
  check_param(HessianS6);
  check_param(nConstituents);
  check_param(aveConstituentPt);
  check_param(logAveConstituentPt);
  check_param(constituentPtDistribution);
  check_param(constituentEtaPhiSpread);
  check_param(chargedHadronEnergyFraction);
  check_param(neutralHadronEnergyFraction);
  check_param(photonEnergyFraction);
  check_param(electronEnergyFraction);
  check_param(muonEnergyFraction);
  check_param(HFHadronEnergyFraction);
  check_param(HFEMEnergyFraction);
  check_param(chargedHadronMultiplicity);
  check_param(neutralHadronMultiplicity);
  check_param(photonMultiplicity);
  check_param(electronMultiplicity);
  check_param(muonMultiplicity);
  check_param(HFHadronMultiplicity);
  check_param(HFEMMultiplicity);
  check_param(chargedEmEnergyFraction);
  check_param(chargedMuEnergyFraction);
  check_param(neutralEmEnergyFraction);
  check_param(EmEnergyFraction);
  check_param(chargedMultiplicity);
  check_param(neutralMultiplicity);

  if (dim != nFactors)
    throw cms::Exception("FFTJetBadConfig")
        << "In FFTGenericScaleCalculator constructor: "
        << "incompatible number of scaling factors: expected " << dim << ", got " << nFactors << std::endl;
  for (int i = 0; i < nFactors; ++i)
    if (mask[i] == 0)
      throw cms::Exception("FFTJetBadConfig") << "In FFTGenericScaleCalculator constructor: "
                                              << "variable number " << i << " is not mapped" << std::endl;
}

~FFTGenericScaleCalculator()

FFTGenericScaleCalculator::~FFTGenericScaleCalculator ( )

inlineoverride

Definition at line 17 of file FFTGenericScaleCalculator.h.

{}

Member Function Documentation

f_safeLog()

double FFTGenericScaleCalculator::f_safeLog ( const double  x ) const

inlineprivate

Definition at line 26 of file FFTGenericScaleCalculator.h.

References dqm-mbProfile::log, m_minLog, and x.

Referenced by mapFFTJet().

                                                {
    if (x > 0.0)
      return log(x);
    else
      return m_minLog;
  }

mapFFTJet()

void FFTGenericScaleCalculator::mapFFTJet ( const reco::Jet &  jet, const reco::FFTJet< float > &  fftJet, const math::XYZTLorentzVector &  current, double *  buf, unsigned  dim  ) const

overridevirtual

Implements AbsFFTSpecificScaleCalculator.

Definition at line 189 of file FFTGenericScaleCalculator.cc.

References cms::cuda::assert(), visDQMUpload::buf, reco::PFJet::chargedEmEnergyFraction(), reco::PFJet::chargedHadronEnergyFraction(), reco::PFJet::chargedHadronMultiplicity(), reco::PFJet::chargedMuEnergyFraction(), reco::PFJet::chargedMultiplicity(), reco::PattRecoPeak< Real >::clusterRadius(), reco::PattRecoPeak< Real >::clusterSeparation(), delPhi(), reco::PattRecoPeak< Real >::driftSpeed(), reco::PFJet::electronEnergyFraction(), reco::PFJet::electronMultiplicity(), reco::PattRecoPeak< Real >::eta(), Exception, reco::FFTJet< Real >::f_convergenceDistance(), reco::FFTJet< Real >::f_etaPhiCorr(), reco::FFTJet< Real >::f_etaWidth(), reco::FFTJet< Real >::f_etSum(), reco::FFTJet< Real >::f_fuzziness(), reco::FFTJet< Real >::f_membershipFactor(), reco::FFTJet< Real >::f_ncells(), reco::FFTJet< Real >::f_phiWidth(), reco::FFTJet< Real >::f_pileup(), reco::FFTJet< Real >::f_precluster(), reco::FFTJet< Real >::f_recoScale(), reco::FFTJet< Real >::f_recoScaleRatio(), f_safeLog(), h, reco::PattRecoPeak< Real >::hessian(), reco::PFJet::HFEMEnergyFraction(), reco::PFJet::HFEMMultiplicity(), reco::PFJet::HFHadronEnergyFraction(), reco::PFJet::HFHadronMultiplicity(), mps_fire::i, metsig::jet, reco::PattRecoPeak< Real >::lifetime(), dqm-mbProfile::log, visualization-live-secondInstance_cfg::m, m_aveConstituentPt, m_averageWidth, m_chargedEmEnergyFraction, m_chargedHadronEnergyFraction, m_chargedHadronMultiplicity, m_chargedMuEnergyFraction, m_chargedMultiplicity, m_clusterRadius, m_clusterSeparation, m_constituentEtaPhiSpread, m_constituentPtDistribution, m_convergenceDistance, m_dRFromJet, m_driftSpeed, m_electronEnergyFraction, m_electronMultiplicity, m_EmEnergyFraction, m_energy, m_eta, m_etaPhiCorr, m_etaWidth, m_etSum, m_factors, m_fuzziness, m_gamma, m_HessianS2, m_HessianS4, m_HessianS6, m_HFEMEnergyFraction, m_HFEMMultiplicity, m_HFHadronEnergyFraction, m_HFHadronMultiplicity, m_LaplacianS1, m_LaplacianS2, m_LaplacianS3, m_lifetime, m_logAveConstituentPt, m_logEnergy, m_logGamma, m_logMagnitude, m_LogMagS1, m_LogMagS2, m_logMass, m_logPt, m_logScale, m_magnitude, m_magS1, m_magS2, m_magSpeed, m_mass, m_membershipFactor, m_mergeTime, m_muonEnergyFraction, m_muonMultiplicity, m_ncells, m_nConstituents, m_nearestNeighborDistance, m_neutralEmEnergyFraction, m_neutralHadronEnergyFraction, m_neutralHadronMultiplicity, m_neutralMultiplicity, m_phi, m_phiWidth, m_photonEnergyFraction, m_photonMultiplicity, m_pileup, m_pt, m_recoScale, m_recoScaleRatio, m_scale, m_splitTime, m_widthRatio, reco::PattRecoPeak< Real >::magnitude(), reco::PattRecoPeak< Real >::magSpeed(), reco::PattRecoPeak< Real >::mergeTime(), reco::PFJet::muonEnergyFraction(), reco::PFJet::muonMultiplicity(), reco::PattRecoPeak< Real >::nearestNeighborDistance(), reco::PFJet::neutralEmEnergyFraction(), reco::PFJet::neutralHadronEnergyFraction(), reco::PFJet::neutralHadronMultiplicity(), reco::PFJet::neutralMultiplicity(), reco::PattRecoPeak< Real >::phi(), reco::PFJet::photonEnergyFraction(), reco::PFJet::photonMultiplicity(), funct::pow(), pfClustersFromCombinedCaloHF_cfi::scale, reco::PattRecoPeak< Real >::scale(), reco::PattRecoPeak< Real >::splitTime(), and mathSSE::sqrt().

                                                                    {
  // Verify that the input is reasonable
  if (dim != m_factors.size())
    throw cms::Exception("FFTJetBadConfig")
        << "In FFTGenericScaleCalculator::mapFFTJet: "
        << "incompatible table dimensionality: expected " << m_factors.size() << ", got " << dim << std::endl;
  if (dim)
    assert(buf);
  else
    return;

  // Go over all variables and map them as configured.
  // Variables from the "current" Lorentz vector.
  if (m_eta >= 0)
    buf[m_eta] = current.eta();

  if (m_phi >= 0)
    buf[m_phi] = current.phi();

  if (m_pt >= 0)
    buf[m_pt] = current.pt();

  if (m_logPt >= 0)
    buf[m_logPt] = f_safeLog(current.pt());

  if (m_mass >= 0)
    buf[m_mass] = current.M();

  if (m_logMass >= 0)
    buf[m_mass] = f_safeLog(current.M());

  if (m_energy >= 0)
    buf[m_energy] = current.e();

  if (m_logEnergy >= 0)
    buf[m_energy] = f_safeLog(current.e());

  if (m_gamma >= 0) {
    const double m = current.M();
    if (m > 0.0)
      buf[m_gamma] = current.e() / m;
    else
      buf[m_gamma] = DBL_MAX;
  }

  if (m_logGamma >= 0) {
    const double m = current.M();
    if (m > 0.0)
      buf[m_gamma] = current.e() / m;
    else
      buf[m_gamma] = DBL_MAX;
    buf[m_gamma] = log(buf[m_gamma]);
  }

  // Variables from fftJet
  if (m_pileup >= 0)
    buf[m_pileup] = fftJet.f_pileup().pt();

  if (m_ncells >= 0)
    buf[m_ncells] = fftJet.f_ncells();

  if (m_etSum >= 0)
    buf[m_etSum] = fftJet.f_etSum();

  if (m_etaWidth >= 0)
    buf[m_etaWidth] = fftJet.f_etaWidth();

  if (m_phiWidth >= 0)
    buf[m_phiWidth] = fftJet.f_phiWidth();

  if (m_averageWidth >= 0) {
    const double etaw = fftJet.f_etaWidth();
    const double phiw = fftJet.f_phiWidth();
    buf[m_averageWidth] = sqrt(etaw * etaw + phiw * phiw);
  }

  if (m_widthRatio >= 0) {
    const double etaw = fftJet.f_etaWidth();
    const double phiw = fftJet.f_phiWidth();
    if (phiw > 0.0)
      buf[m_widthRatio] = etaw / phiw;
    else
      buf[m_widthRatio] = DBL_MAX;
  }

  if (m_etaPhiCorr >= 0)
    buf[m_etaPhiCorr] = fftJet.f_etaPhiCorr();

  if (m_fuzziness >= 0)
    buf[m_fuzziness] = fftJet.f_fuzziness();

  if (m_convergenceDistance >= 0)
    buf[m_convergenceDistance] = fftJet.f_convergenceDistance();

  if (m_recoScale >= 0)
    buf[m_recoScale] = fftJet.f_recoScale();

  if (m_recoScaleRatio >= 0)
    buf[m_recoScaleRatio] = fftJet.f_recoScaleRatio();

  if (m_membershipFactor >= 0)
    buf[m_membershipFactor] = fftJet.f_membershipFactor();

  // Get most often used precluster quantities
  const reco::PattRecoPeak<float>& preclus = fftJet.f_precluster();
  const double scale = preclus.scale();

  if (m_magnitude >= 0)
    buf[m_magnitude] = preclus.magnitude();

  if (m_logMagnitude >= 0)
    buf[m_logMagnitude] = f_safeLog(preclus.magnitude());

  if (m_magS1 >= 0)
    buf[m_magS1] = preclus.magnitude() * scale;

  if (m_LogMagS1 >= 0)
    buf[m_LogMagS1] = f_safeLog(preclus.magnitude() * scale);

  if (m_magS2 >= 0)
    buf[m_magS2] = preclus.magnitude() * scale * scale;

  if (m_LogMagS2 >= 0)
    buf[m_LogMagS2] = f_safeLog(preclus.magnitude() * scale * scale);

  if (m_driftSpeed >= 0)
    buf[m_driftSpeed] = preclus.driftSpeed();

  if (m_magSpeed >= 0)
    buf[m_magSpeed] = preclus.magSpeed();

  if (m_lifetime >= 0)
    buf[m_lifetime] = preclus.lifetime();

  if (m_splitTime >= 0)
    buf[m_splitTime] = preclus.splitTime();

  if (m_mergeTime >= 0)
    buf[m_mergeTime] = preclus.mergeTime();

  if (m_scale >= 0)
    buf[m_scale] = scale;

  if (m_logScale >= 0)
    buf[m_logScale] = f_safeLog(scale);

  if (m_nearestNeighborDistance >= 0)
    buf[m_nearestNeighborDistance] = preclus.nearestNeighborDistance();

  if (m_clusterRadius >= 0)
    buf[m_clusterRadius] = preclus.clusterRadius();

  if (m_clusterSeparation >= 0)
    buf[m_clusterSeparation] = preclus.clusterSeparation();

  if (m_dRFromJet >= 0) {
    const double deta = preclus.eta() - current.eta();
    const double dphi = delPhi(preclus.phi(), current.phi());
    buf[m_dRFromJet] = sqrt(deta * deta + dphi * dphi);
  }

  if (m_LaplacianS1 >= 0) {
    double h[3];
    preclus.hessian(h);
    buf[m_LaplacianS1] = fabs(h[0] + h[2]) * scale;
  }

  if (m_LaplacianS2 >= 0) {
    double h[3];
    preclus.hessian(h);
    buf[m_LaplacianS2] = fabs(h[0] + h[2]) * scale * scale;
  }

  if (m_LaplacianS3 >= 0) {
    double h[3];
    preclus.hessian(h);
    buf[m_LaplacianS3] = fabs(h[0] + h[2]) * scale * scale * scale;
  }

  if (m_HessianS2 >= 0) {
    double h[3];
    preclus.hessian(h);
    buf[m_HessianS2] = fabs(h[0] * h[2] - h[1] * h[1]) * scale * scale;
  }

  if (m_HessianS4 >= 0) {
    double h[3];
    preclus.hessian(h);
    buf[m_HessianS4] = fabs(h[0] * h[2] - h[1] * h[1]) * pow(scale, 4);
  }

  if (m_HessianS6 >= 0) {
    double h[3];
    preclus.hessian(h);
    buf[m_HessianS6] = fabs(h[0] * h[2] - h[1] * h[1]) * pow(scale, 6);
  }

  // Variables from reco::Jet
  if (m_nConstituents >= 0)
    buf[m_nConstituents] = jet.nConstituents();

  if (m_aveConstituentPt >= 0)
    buf[m_aveConstituentPt] = current.pt() / jet.nConstituents();

  if (m_logAveConstituentPt >= 0)
    buf[m_logAveConstituentPt] = f_safeLog(current.pt() / jet.nConstituents());

  if (m_constituentPtDistribution >= 0)
    buf[m_constituentPtDistribution] = jet.constituentPtDistribution();

  if (m_constituentEtaPhiSpread >= 0)
    buf[m_constituentEtaPhiSpread] = jet.constituentEtaPhiSpread();

  // Variables from reco::PFJet
  const reco::PFJet* pfjet = dynamic_cast<const reco::PFJet*>(&jet);
  if (pfjet) {
    // Particle flow jet
    if (m_chargedHadronEnergyFraction >= 0)
      buf[m_chargedHadronEnergyFraction] = pfjet->chargedHadronEnergyFraction();

    if (m_neutralHadronEnergyFraction >= 0)
      buf[m_neutralHadronEnergyFraction] = pfjet->neutralHadronEnergyFraction();

    if (m_photonEnergyFraction >= 0)
      buf[m_photonEnergyFraction] = pfjet->photonEnergyFraction();

    if (m_electronEnergyFraction >= 0)
      buf[m_electronEnergyFraction] = pfjet->electronEnergyFraction();

    if (m_muonEnergyFraction >= 0)
      buf[m_muonEnergyFraction] = pfjet->muonEnergyFraction();

    if (m_HFHadronEnergyFraction >= 0)
      buf[m_HFHadronEnergyFraction] = pfjet->HFHadronEnergyFraction();

    if (m_HFEMEnergyFraction >= 0)
      buf[m_HFEMEnergyFraction] = pfjet->HFEMEnergyFraction();

    if (m_chargedHadronMultiplicity >= 0)
      buf[m_chargedHadronMultiplicity] = pfjet->chargedHadronMultiplicity();

    if (m_neutralHadronMultiplicity >= 0)
      buf[m_neutralHadronMultiplicity] = pfjet->neutralHadronMultiplicity();

    if (m_photonMultiplicity >= 0)
      buf[m_photonMultiplicity] = pfjet->photonMultiplicity();

    if (m_electronMultiplicity >= 0)
      buf[m_electronMultiplicity] = pfjet->electronMultiplicity();

    if (m_muonMultiplicity >= 0)
      buf[m_muonMultiplicity] = pfjet->muonMultiplicity();

    if (m_HFHadronMultiplicity >= 0)
      buf[m_HFHadronMultiplicity] = pfjet->HFHadronMultiplicity();

    if (m_HFEMMultiplicity >= 0)
      buf[m_HFEMMultiplicity] = pfjet->HFEMMultiplicity();

    if (m_chargedEmEnergyFraction >= 0)
      buf[m_chargedEmEnergyFraction] = pfjet->chargedEmEnergyFraction();

    if (m_chargedMuEnergyFraction >= 0)
      buf[m_chargedMuEnergyFraction] = pfjet->chargedMuEnergyFraction();

    if (m_neutralEmEnergyFraction >= 0)
      buf[m_neutralEmEnergyFraction] = pfjet->neutralEmEnergyFraction();

    if (m_EmEnergyFraction >= 0)
      buf[m_EmEnergyFraction] = pfjet->neutralEmEnergyFraction() + pfjet->chargedEmEnergyFraction();

    if (m_chargedMultiplicity >= 0)
      buf[m_chargedMultiplicity] = pfjet->chargedMultiplicity();

    if (m_neutralMultiplicity >= 0)
      buf[m_neutralMultiplicity] = pfjet->neutralMultiplicity();
  } else {
    // Not a particle flow jet
    if (m_chargedHadronEnergyFraction >= 0 || m_neutralHadronEnergyFraction >= 0 || m_photonEnergyFraction >= 0 ||
        m_electronEnergyFraction >= 0 || m_muonEnergyFraction >= 0 || m_HFHadronEnergyFraction >= 0 ||
        m_HFEMEnergyFraction >= 0 || m_chargedHadronMultiplicity >= 0 || m_neutralHadronMultiplicity >= 0 ||
        m_photonMultiplicity >= 0 || m_electronMultiplicity >= 0 || m_muonMultiplicity >= 0 ||
        m_HFHadronMultiplicity >= 0 || m_HFEMMultiplicity >= 0 || m_chargedEmEnergyFraction >= 0 ||
        m_chargedMuEnergyFraction >= 0 || m_neutralEmEnergyFraction >= 0 || m_EmEnergyFraction >= 0 ||
        m_chargedMultiplicity >= 0 || m_neutralMultiplicity >= 0)
      throw cms::Exception("FFTJetBadConfig") << "In FFTGenericScaleCalculator::mapFFTJet: "
                                              << "this configuration is valid for particle flow jets only" << std::endl;
  }

  // Apply the scaling factors
  for (unsigned i = 0; i < dim; ++i)
    buf[i] *= m_factors[i];
}

Member Data Documentation

m_aveConstituentPt

int FFTGenericScaleCalculator::m_aveConstituentPt

private

Definition at line 90 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_averageWidth

int FFTGenericScaleCalculator::m_averageWidth

private

Definition at line 54 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_chargedEmEnergyFraction

int FFTGenericScaleCalculator::m_chargedEmEnergyFraction

private

Definition at line 110 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_chargedHadronEnergyFraction

int FFTGenericScaleCalculator::m_chargedHadronEnergyFraction

private

Definition at line 96 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_chargedHadronMultiplicity

int FFTGenericScaleCalculator::m_chargedHadronMultiplicity

private

Definition at line 103 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_chargedMuEnergyFraction

int FFTGenericScaleCalculator::m_chargedMuEnergyFraction

private

Definition at line 111 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_chargedMultiplicity

int FFTGenericScaleCalculator::m_chargedMultiplicity

private

Definition at line 114 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_clusterRadius

int FFTGenericScaleCalculator::m_clusterRadius

private

Definition at line 78 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_clusterSeparation

int FFTGenericScaleCalculator::m_clusterSeparation

private

Definition at line 79 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_constituentEtaPhiSpread

int FFTGenericScaleCalculator::m_constituentEtaPhiSpread

private

Definition at line 93 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_constituentPtDistribution

int FFTGenericScaleCalculator::m_constituentPtDistribution

private

Definition at line 92 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_convergenceDistance

int FFTGenericScaleCalculator::m_convergenceDistance

private

Definition at line 58 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_dRFromJet

int FFTGenericScaleCalculator::m_dRFromJet

private

Definition at line 80 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_driftSpeed

int FFTGenericScaleCalculator::m_driftSpeed

private

Definition at line 70 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_electronEnergyFraction

int FFTGenericScaleCalculator::m_electronEnergyFraction

private

Definition at line 99 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_electronMultiplicity

int FFTGenericScaleCalculator::m_electronMultiplicity

private

Definition at line 106 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_EmEnergyFraction

int FFTGenericScaleCalculator::m_EmEnergyFraction

private

Definition at line 113 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_energy

int FFTGenericScaleCalculator::m_energy

private

Definition at line 43 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_eta

int FFTGenericScaleCalculator::m_eta

private

Definition at line 37 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_etaPhiCorr

int FFTGenericScaleCalculator::m_etaPhiCorr

private

Definition at line 56 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_etaWidth

int FFTGenericScaleCalculator::m_etaWidth

private

Definition at line 52 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_etSum

int FFTGenericScaleCalculator::m_etSum

private

Definition at line 51 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_factors

std::vector<double> FFTGenericScaleCalculator::m_factors

private

Definition at line 33 of file FFTGenericScaleCalculator.h.

Referenced by FFTGenericScaleCalculator(), and mapFFTJet().

m_fuzziness

int FFTGenericScaleCalculator::m_fuzziness

private

Definition at line 57 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_gamma

int FFTGenericScaleCalculator::m_gamma

private

Definition at line 45 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_HessianS2

int FFTGenericScaleCalculator::m_HessianS2

private

Definition at line 84 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_HessianS4

int FFTGenericScaleCalculator::m_HessianS4

private

Definition at line 85 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_HessianS6

int FFTGenericScaleCalculator::m_HessianS6

private

Definition at line 86 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_HFEMEnergyFraction

int FFTGenericScaleCalculator::m_HFEMEnergyFraction

private

Definition at line 102 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_HFEMMultiplicity

int FFTGenericScaleCalculator::m_HFEMMultiplicity

private

Definition at line 109 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_HFHadronEnergyFraction

int FFTGenericScaleCalculator::m_HFHadronEnergyFraction

private

Definition at line 101 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_HFHadronMultiplicity

int FFTGenericScaleCalculator::m_HFHadronMultiplicity

private

Definition at line 108 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_LaplacianS1

int FFTGenericScaleCalculator::m_LaplacianS1

private

Definition at line 81 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_LaplacianS2

int FFTGenericScaleCalculator::m_LaplacianS2

private

Definition at line 82 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_LaplacianS3

int FFTGenericScaleCalculator::m_LaplacianS3

private

Definition at line 83 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_lifetime

int FFTGenericScaleCalculator::m_lifetime

private

Definition at line 72 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_logAveConstituentPt

int FFTGenericScaleCalculator::m_logAveConstituentPt

private

Definition at line 91 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_logEnergy

int FFTGenericScaleCalculator::m_logEnergy

private

Definition at line 44 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_logGamma

int FFTGenericScaleCalculator::m_logGamma

private

Definition at line 46 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_logMagnitude

int FFTGenericScaleCalculator::m_logMagnitude

private

Definition at line 65 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_LogMagS1

int FFTGenericScaleCalculator::m_LogMagS1

private

Definition at line 67 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_LogMagS2

int FFTGenericScaleCalculator::m_LogMagS2

private

Definition at line 69 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_logMass

int FFTGenericScaleCalculator::m_logMass

private

Definition at line 42 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_logPt

int FFTGenericScaleCalculator::m_logPt

private

Definition at line 40 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_logScale

int FFTGenericScaleCalculator::m_logScale

private

Definition at line 76 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_magnitude

int FFTGenericScaleCalculator::m_magnitude

private

Definition at line 64 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_magS1

int FFTGenericScaleCalculator::m_magS1

private

Definition at line 66 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_magS2

int FFTGenericScaleCalculator::m_magS2

private

Definition at line 68 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_magSpeed

int FFTGenericScaleCalculator::m_magSpeed

private

Definition at line 71 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_mass

int FFTGenericScaleCalculator::m_mass

private

Definition at line 41 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_membershipFactor

int FFTGenericScaleCalculator::m_membershipFactor

private

Definition at line 61 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_mergeTime

int FFTGenericScaleCalculator::m_mergeTime

private

Definition at line 74 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_minLog

double FFTGenericScaleCalculator::m_minLog

private

Definition at line 34 of file FFTGenericScaleCalculator.h.

Referenced by f_safeLog().

m_muonEnergyFraction

int FFTGenericScaleCalculator::m_muonEnergyFraction

private

Definition at line 100 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_muonMultiplicity

int FFTGenericScaleCalculator::m_muonMultiplicity

private

Definition at line 107 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_ncells

int FFTGenericScaleCalculator::m_ncells

private

Definition at line 50 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_nConstituents

int FFTGenericScaleCalculator::m_nConstituents

private

Definition at line 89 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_nearestNeighborDistance

int FFTGenericScaleCalculator::m_nearestNeighborDistance

private

Definition at line 77 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_neutralEmEnergyFraction

int FFTGenericScaleCalculator::m_neutralEmEnergyFraction

private

Definition at line 112 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_neutralHadronEnergyFraction

int FFTGenericScaleCalculator::m_neutralHadronEnergyFraction

private

Definition at line 97 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_neutralHadronMultiplicity

int FFTGenericScaleCalculator::m_neutralHadronMultiplicity

private

Definition at line 104 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_neutralMultiplicity

int FFTGenericScaleCalculator::m_neutralMultiplicity

private

Definition at line 115 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_phi

int FFTGenericScaleCalculator::m_phi

private

Definition at line 38 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_phiWidth

int FFTGenericScaleCalculator::m_phiWidth

private

Definition at line 53 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_photonEnergyFraction

int FFTGenericScaleCalculator::m_photonEnergyFraction

private

Definition at line 98 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_photonMultiplicity

int FFTGenericScaleCalculator::m_photonMultiplicity

private

Definition at line 105 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_pileup

int FFTGenericScaleCalculator::m_pileup

private

Definition at line 49 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_pt

int FFTGenericScaleCalculator::m_pt

private

Definition at line 39 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_recoScale

int FFTGenericScaleCalculator::m_recoScale

private

Definition at line 59 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_recoScaleRatio

int FFTGenericScaleCalculator::m_recoScaleRatio

private

Definition at line 60 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_scale

int FFTGenericScaleCalculator::m_scale

private

Definition at line 75 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_splitTime

int FFTGenericScaleCalculator::m_splitTime

private

Definition at line 73 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

m_widthRatio

int FFTGenericScaleCalculator::m_widthRatio

private

Definition at line 55 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().