/data/refman/pasoursint/CMSSW_4_1_8_patch13/src/GeneratorInterface/LHEInterface/interface/JetInput.h

Go to the documentation of this file.

#ifndef GeneratorInterface_LHEInterface_JetInput_h
#define GeneratorInterface_LHEInterface_JetInput_h

#include <vector>

#include <HepMC/GenEvent.h>
#include <HepMC/GenParticle.h>
#include <HepMC/GenVertex.h>

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

namespace lhef {

class JetInput {
    public:
        typedef std::vector<bool>                       ParticleBitmap;
        typedef std::vector<const HepMC::GenParticle*>  ParticleVector;
        typedef std::vector<const HepMC::GenVertex*>    VertexVector;

        JetInput();
        JetInput(const edm::ParameterSet &params);
        ~JetInput();

        ParticleVector operator () (const HepMC::GenEvent *event) const;

        bool getPartonicFinalState() const { return partonicFinalState; }
        bool getHardProcessOnly() const { return onlyHardProcess; }
        bool getTausAndJets() const { return tausAsJets; }
        bool getExcludeResonances() const { return excludeResonances; }
        double getPtMin() const { return ptMin; }
        const std::vector<unsigned int> &getIgnoredParticles() const
        { return ignoreParticleIDs; }
        const std::vector<unsigned int> &getExcludedResonances() const
        { return excludedResonances; }
        const std::vector<unsigned int> &getExcludedFromResonances() const
        { return excludedFromResonances; }

        void setPartonicFinalState(bool flag = true)
        { partonicFinalState = flag; }
        void setHardProcessOnly(bool flag = true)
        { onlyHardProcess = flag; }
        void setTausAsJets(bool flag = true) { tausAsJets = flag; }
        void setExcludeResonances(bool flag = true) { excludeResonances = flag; }
        void setPtMin(double ptMin) { this->ptMin = ptMin; }
        void setIgnoredParticles(const std::vector<unsigned int> &particleIDs);
        void setExcludedResonances(const std::vector<unsigned int> &particleIds);
        void setExcludedFromResonances(const std::vector<unsigned int> &particleIds);

        bool isParton(int pdgId) const;
        static bool isHadron(int pdgId);
        bool isResonance(int pdgId) const;
        bool isExcludedFromResonances(int pdgId) const;
        bool isHardProcess(const HepMC::GenVertex *vertex,
                           const VertexVector &hardProcess) const;
        bool isIgnored(int pdgId) const;

        enum ResonanceState {
                kNo = 0,
                kDirect,
                kIndirect
        };

        bool hasPartonChildren(ParticleBitmap &invalid,
                               const ParticleVector &p,
                               const HepMC::GenParticle *particle) const;
        bool fromHardProcess(ParticleBitmap &invalid,
                             const ParticleVector &p,
                             const HepMC::GenParticle *particle,
                             const VertexVector &hardProcess) const;
        bool fromSignalVertex(ParticleBitmap &invalid,
                              const ParticleVector &p,
                              const HepMC::GenParticle *particle,
                              const HepMC::GenVertex *signalVertex) const;
        ResonanceState fromResonance(ParticleBitmap &invalid,
                                     const ParticleVector &p,
                                     const HepMC::GenParticle *particle,
                                     const HepMC::GenVertex *signalVertex,
                                     const VertexVector &hardProcess) const;

    private:
        int testPartonChildren(ParticleBitmap &invalid,
                               const ParticleVector &p,
                               const HepMC::GenVertex *v) const;

        std::vector<unsigned int>       ignoreParticleIDs;
        std::vector<unsigned int>       excludedResonances;
        std::vector<unsigned int>       excludedFromResonances;
        bool                            partonicFinalState;
        bool                            onlyHardProcess;
        bool                            excludeResonances;
        bool                            tausAsJets;
        double                          ptMin;
};

} // namespace lhef

#endif // GeneratorCommon_LHEInterface_JetInput_h