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

(

const edm::ParameterSet &

ps

)

Definition at line 32 of file FFTGenericScaleCalculator.cc.

References reco::btau::chargedHadronEnergyFraction, reco::btau::chargedHadronMultiplicity, check_param, fftjetproducer_cfi::convergenceDistance, reco::btau::electronEnergyFraction, reco::btau::electronMultiplicity, PVValHelper::eta, Exception, CustomPhysics_cfi::gamma, mps_fire::i, m_factors, RecoTauDiscriminantConfiguration::mask, ResonanceBuilder::mass, reco::btau::muonEnergyFraction, reco::btau::muonMultiplicity, jets_cff::nConstituents, reco::btau::neutralHadronEnergyFraction, reco::btau::neutralHadronMultiplicity, phi, reco::btau::photonEnergyFraction, reco::btau::photonMultiplicity, estimatePileup_makeJSON::pileup, EnergyCorrector::pt, and Scenarios_cff::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 ( )

inlineoverride

Definition at line 18 of file FFTGenericScaleCalculator.h.

References metsig::jet, and mapFFTJet().

{}

Member Function Documentation

double FFTGenericScaleCalculator::f_safeLog ( const double  x ) const

inlineprivate

Definition at line 25 of file FFTGenericScaleCalculator.h.

References cmsBatch::log, and m_minLog.

Referenced by mapFFTJet().

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

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 195 of file FFTGenericScaleCalculator.cc.

References reco::PFJet::chargedEmEnergyFraction(), reco::PFJet::chargedHadronEnergyFraction(), reco::PFJet::chargedHadronMultiplicity(), reco::PFJet::chargedMuEnergyFraction(), reco::PFJet::chargedMultiplicity(), reco::PattRecoPeak< Real >::clusterRadius(), reco::PattRecoPeak< Real >::clusterSeparation(), reco::Jet::constituentEtaPhiSpread(), reco::Jet::constituentPtDistribution(), 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(), 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(), cmsBatch::log, funct::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::Jet::nConstituents(), 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(), reco::PattRecoPeak< Real >::scale(), Scenarios_cff::scale, reco::PattRecoPeak< Real >::splitTime(), and mathSSE::sqrt().

Referenced by ~FFTGenericScaleCalculator().

{
    // 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

int FFTGenericScaleCalculator::m_aveConstituentPt

private

Definition at line 90 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_averageWidth

private

Definition at line 54 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_chargedEmEnergyFraction

private

Definition at line 110 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_chargedHadronEnergyFraction

private

Definition at line 96 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_chargedHadronMultiplicity

private

Definition at line 103 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_chargedMuEnergyFraction

private

Definition at line 111 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_chargedMultiplicity

private

Definition at line 114 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_clusterRadius

private

Definition at line 78 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_clusterSeparation

private

Definition at line 79 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_constituentEtaPhiSpread

private

Definition at line 93 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_constituentPtDistribution

private

Definition at line 92 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_convergenceDistance

private

Definition at line 58 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_dRFromJet

private

Definition at line 80 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_driftSpeed

private

Definition at line 70 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_electronEnergyFraction

private

Definition at line 99 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_electronMultiplicity

private

Definition at line 106 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_EmEnergyFraction

private

Definition at line 113 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_energy

private

Definition at line 43 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_eta

private

Definition at line 37 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_etaPhiCorr

private

Definition at line 56 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_etaWidth

private

Definition at line 52 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_etSum

private

Definition at line 51 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

std::vector<double> FFTGenericScaleCalculator::m_factors

private

Definition at line 33 of file FFTGenericScaleCalculator.h.

Referenced by FFTGenericScaleCalculator(), and mapFFTJet().

int FFTGenericScaleCalculator::m_fuzziness

private

Definition at line 57 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_gamma

private

Definition at line 45 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_HessianS2

private

Definition at line 84 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_HessianS4

private

Definition at line 85 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_HessianS6

private

Definition at line 86 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_HFEMEnergyFraction

private

Definition at line 102 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_HFEMMultiplicity

private

Definition at line 109 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_HFHadronEnergyFraction

private

Definition at line 101 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_HFHadronMultiplicity

private

Definition at line 108 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_LaplacianS1

private

Definition at line 81 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_LaplacianS2

private

Definition at line 82 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_LaplacianS3

private

Definition at line 83 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_lifetime

private

Definition at line 72 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_logAveConstituentPt

private

Definition at line 91 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_logEnergy

private

Definition at line 44 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_logGamma

private

Definition at line 46 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_logMagnitude

private

Definition at line 65 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_LogMagS1

private

Definition at line 67 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_LogMagS2

private

Definition at line 69 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_logMass

private

Definition at line 42 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_logPt

private

Definition at line 40 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_logScale

private

Definition at line 76 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_magnitude

private

Definition at line 64 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_magS1

private

Definition at line 66 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_magS2

private

Definition at line 68 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_magSpeed

private

Definition at line 71 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_mass

private

Definition at line 41 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_membershipFactor

private

Definition at line 61 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_mergeTime

private

Definition at line 74 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

double FFTGenericScaleCalculator::m_minLog

private

Definition at line 34 of file FFTGenericScaleCalculator.h.

Referenced by f_safeLog().

int FFTGenericScaleCalculator::m_muonEnergyFraction

private

Definition at line 100 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_muonMultiplicity

private

Definition at line 107 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_ncells

private

Definition at line 50 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_nConstituents

private

Definition at line 89 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_nearestNeighborDistance

private

Definition at line 77 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_neutralEmEnergyFraction

private

Definition at line 112 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_neutralHadronEnergyFraction

private

Definition at line 97 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_neutralHadronMultiplicity

private

Definition at line 104 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_neutralMultiplicity

private

Definition at line 115 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_phi

private

Definition at line 38 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_phiWidth

private

Definition at line 53 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_photonEnergyFraction

private

Definition at line 98 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_photonMultiplicity

private

Definition at line 105 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_pileup

private

Definition at line 49 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_pt

private

Definition at line 39 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_recoScale

private

Definition at line 59 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_recoScaleRatio

private

Definition at line 60 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_scale

private

Definition at line 75 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_splitTime

private

Definition at line 73 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().

int FFTGenericScaleCalculator::m_widthRatio

private

Definition at line 55 of file FFTGenericScaleCalculator.h.

Referenced by mapFFTJet().