/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/GeneratorInterface/LHEInterface/interface/JetClustering.h

Go to the documentation of this file.

#ifndef GeneratorInterface_LHEInterface_JetClustering_h
#define GeneratorInterface_LHEInterface_JetClustering_h

#include <memory>
#include <vector>

#include <Math/GenVector/PxPyPzE4D.h>

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "GeneratorInterface/LHEInterface/interface/JetInput.h"

namespace lhef {

class JetClustering {
    public:
        typedef JetInput::ParticleVector        ParticleVector;
        typedef ROOT::Math::PxPyPzE4D<double>   FourVector;

        class Jet {
            public:
                Jet() {}
                Jet(const FourVector &p4) : p4_(p4) {}
                Jet(const FourVector &p4, const ParticleVector &constituents) :
                        p4_(p4), constituents_(constituents) {}
                Jet(double px, double py, double pz, double e) :
                        p4_(px, py, pz, e) {}
                Jet(double px, double py, double pz, double e,
                    const ParticleVector &constituents) :
                        p4_(px, py, pz, e), constituents_(constituents) {}
                Jet(ParticleVector::value_type item) :
                        p4_(item->momentum().px(), item->momentum().py(),
                            item->momentum().pz(), item->momentum().e()),
                        constituents_(1) { constituents_[0] = item; }

                const FourVector &p4() const { return p4_; }
                const ParticleVector &constituents() const { return constituents_; }

                double px() const { return p4_.Px(); }
                double py() const { return p4_.Py(); }
                double pz() const { return p4_.Pz(); }
                double e() const { return p4_.E(); }

                double momentum() const { return p4_.P(); }
                double pt() const { return p4_.Perp(); }
                double et() const { return p4_.Et(); }
                double theta() const { return p4_.Theta(); }
                double eta() const { return p4_.Eta(); }
                double phi() const { return p4_.Phi(); }
                double m() const { return p4_.M(); }

            private:
                FourVector      p4_;
                ParticleVector  constituents_;
        };

        JetClustering(const edm::ParameterSet &params);
        JetClustering(const edm::ParameterSet &params, double jetPtMin);
        ~JetClustering();

        std::vector<Jet> operator () (const ParticleVector &input) const;

        double getJetPtMin() const;

        class Algorithm;

    private:
        void init(const edm::ParameterSet &params, double jetPtMin);

        std::auto_ptr<Algorithm>        jetAlgo;
};

} // namespace lhef

#endif // GeneratorCommon_LHEInterface_JetClustering_h