#include <FFTJetInterface.h>

Inheritance diagram for fftjetcms::FFTJetInterface:

Public Types
enum	JetType { BASICJET = 0, GENJET, CALOJET, PFJET, TRACKJET, JPTJET }
Public Member Functions
virtual	~FFTJetInterface ()
Static Public Member Functions
static JetType	parse_jet_type (const std::string &name)
Protected Member Functions
template<class Ptr >
void	checkConfig (const Ptr &ptr, const char *message)
void	discretizeEnergyFlow ()
	FFTJetInterface (const edm::ParameterSet &)
double	getEventScale () const
void	loadInputCollection (const edm::Event &)
bool	storeInSinglePrecision () const
const reco::Particle::Point &	vertexUsed () const
Protected Attributes
const AnomalousTower	anomalous
std::vector< unsigned >	candidateIndex
const bool	doPVCorrection
std::auto_ptr< fftjet::Grid2d < fftjetcms::Real > >	energyFlow
const std::vector< double >	etaDependentMagnutideFactors
std::vector < fftjetcms::VectorLike >	eventData
edm::Handle< reco::CandidateView >	inputCollection
const edm::InputTag	inputLabel
const JetType	jetType
const std::string	outputLabel
const edm::InputTag	srcPVs
Private Member Functions
	FFTJetInterface ()
	FFTJetInterface (const FFTJetInterface &)
FFTJetInterface &	operator= (const FFTJetInterface &)
Private Attributes
const double	completeEventScale
const bool	insertCompleteEvent
reco::Particle::Point	vertex_

Detailed Description

Definition at line 48 of file FFTJetInterface.h.

Member Enumeration Documentation

enum fftjetcms::FFTJetInterface::JetType

Enumerator:

BASICJET
GENJET
CALOJET
PFJET
TRACKJET
JPTJET

Definition at line 51 of file FFTJetInterface.h.

      {
        BASICJET = 0,
        GENJET,
        CALOJET,
        PFJET,
        TRACKJET,
        JPTJET
      };

Constructor & Destructor Documentation

virtual fftjetcms::FFTJetInterface::~FFTJetInterface ( ) [inline, virtual]

Definition at line 61 of file FFTJetInterface.h.

{}

FFTJetInterface::FFTJetInterface ( const edm::ParameterSet & ps ) [explicit, protected]

Definition at line 46 of file FFTJetInterface.cc.

References completeEventScale, Exception, and insertCompleteEvent.

    : inputLabel(ps.getParameter<edm::InputTag>("src")),
      init_param(std::string, outputLabel),
      jetType(parse_jet_type(ps.getParameter<std::string>("jetType"))),
      init_param(bool, doPVCorrection),
      init_param(edm::InputTag, srcPVs),
      etaDependentMagnutideFactors(
          ps.getParameter<std::vector<double> >(
              "etaDependentMagnutideFactors")),
      init_param(edm::ParameterSet, anomalous),
      init_param(bool, insertCompleteEvent),
      init_param(double, completeEventScale),
      vertex_(0.0, 0.0, 0.0)
{
      if (insertCompleteEvent && completeEventScale <= 0.0)
        throw cms::Exception("FFTJetBadConfig")
          << "Bad scale for the complete event : must be positive"
          << std::endl;
}

fftjetcms::FFTJetInterface::FFTJetInterface ( ) [private]

fftjetcms::FFTJetInterface::FFTJetInterface ( const FFTJetInterface & ) [private]

Member Function Documentation

template<class Ptr >

void fftjetcms::FFTJetInterface::checkConfig	(	const Ptr &	ptr,
		const char *	message
	)		`[inline, protected]`

Definition at line 69 of file FFTJetInterface.h.

References NULL.

Referenced by FFTJetProducer::beginJob(), FFTJetEFlowSmoother::FFTJetEFlowSmoother(), FFTJetPatRecoProducer::FFTJetPatRecoProducer(), FFTJetPileupProcessor::FFTJetPileupProcessor(), and FFTJetProducer::FFTJetProducer().

    {
      if (ptr.get() == NULL)
        throw cms::Exception("FFTJetBadConfig") << message << std::endl;
    }

void FFTJetInterface::discretizeEnergyFlow ( ) [protected]

Definition at line 119 of file FFTJetInterface.cc.

References energyFlow, etaDependentMagnutideFactors, eventData, g, and i.

Referenced by FFTJetPatRecoProducer::produce(), FFTJetProducer::produce(), FFTJetPileupProcessor::produce(), and FFTJetEFlowSmoother::produce().

{
    // It is a bug to call this function before defining the energy flow grid
    assert(energyFlow.get());

    fftjet::Grid2d<Real>& g(*energyFlow);
    g.reset();

    const unsigned nInputs = eventData.size();
    const VectorLike* inp = nInputs ? &eventData[0] : 0;
    for (unsigned i=0; i<nInputs; ++i)
    {
        const VectorLike& item(inp[i]);
        g.fill(item.Eta(), item.Phi(), item.Et());
    }

    if (!etaDependentMagnutideFactors.empty())
    {
        if (etaDependentMagnutideFactors.size() != g.nEta())
            throw cms::Exception("FFTJetBadConfig")
                << "ERROR in FFTJetInterface::discretizeEnergyFlow() :"
                " number of elements in the \"etaDependentMagnutideFactors\""
                " vector is inconsistent with the grid binning"
                << std::endl;
        g.scaleData(&etaDependentMagnutideFactors[0],
                    etaDependentMagnutideFactors.size());
    }
}

double FFTJetInterface::getEventScale ( ) const [protected]

Definition at line 67 of file FFTJetInterface.cc.

References completeEventScale, and insertCompleteEvent.

Referenced by FFTJetPatRecoProducer::buildDenseProduct(), FFTJetPatRecoProducer::buildSparseProduct(), FFTJetPatRecoProducer::FFTJetPatRecoProducer(), FFTJetProducer::loadSparseTreeData(), FFTJetPatRecoProducer::produce(), and FFTJetEFlowSmoother::produce().

{
     return insertCompleteEvent ? completeEventScale : 0.0;
}

void FFTJetInterface::loadInputCollection ( const edm::Event & iEvent ) [protected]

Definition at line 73 of file FFTJetInterface.cc.

References anomalous, CALOJET, candidateIndex, doPVCorrection, end, eventData, edm::Event::getByLabel(), getHLTprescales::index, inputCollection, inputLabel, edm::detail::isnan(), jetType, reco::Candidate::p4(), CaloTower::p4(), reco::Candidate::pt(), srcPVs, and vertex_.

Referenced by FFTJetPatRecoProducer::produce(), FFTJetProducer::produce(), FFTJetPileupProcessor::produce(), and FFTJetEFlowSmoother::produce().

{
    // Figure out if we are going to perform the vertex adjustment
    const bool adjustForVertex = doPVCorrection && jetType == CALOJET;

    // Figure out the vertex
    if (adjustForVertex)
    {
        edm::Handle<reco::VertexCollection> pvCollection;
        iEvent.getByLabel(srcPVs, pvCollection);
        if (pvCollection->empty())
            vertex_ = reco::Particle::Point(0.0, 0.0, 0.0);
        else
            vertex_ = pvCollection->begin()->position();
    }

    // Get the input collection
    iEvent.getByLabel(inputLabel, inputCollection);

    // Create the set of 4-vectors needed by the algorithm
    eventData.clear();
    candidateIndex.clear();
    unsigned index = 0;
    const reco::CandidateView::const_iterator end = inputCollection->end();
    for (reco::CandidateView::const_iterator it = inputCollection->begin();
         it != end; ++it, ++index)
    {
        const reco::Candidate& item(*it);
        if (anomalous(item))
            continue;
        if (std::isnan(item.pt()))
            continue;

        if (adjustForVertex)
        {
            const CaloTower& tower(dynamic_cast<const CaloTower&>(item));
            eventData.push_back(VectorLike(tower.p4(vertex_)));
        }
        else
            eventData.push_back(item.p4());
        candidateIndex.push_back(index);
    }
    assert(eventData.size() == candidateIndex.size());
}

FFTJetInterface& fftjetcms::FFTJetInterface::operator= ( const FFTJetInterface & ) [private]

FFTJetInterface::JetType FFTJetInterface::parse_jet_type ( const std::string & name ) [static]

Definition at line 24 of file FFTJetInterface.cc.

References Exception.

{
    if (!name.compare("BasicJet"))
        return BASICJET;
    else if (!name.compare("GenJet"))
        return GENJET;
    else if (!name.compare("CaloJet"))
        return CALOJET;
    else if (!name.compare("PFJet"))
        return PFJET;
    else if (!name.compare("TrackJet"))
        return TRACKJET;
    else if (!name.compare("JPTJet"))
        return JPTJET;
    else
        throw cms::Exception("FFTJetBadConfig")
            << "Unsupported jet type specification \""
            << name << "\"" << std::endl;
}