FastJets.hh

// -*- C++ -*-
#ifndef RIVET_FastJets_HH
#define RIVET_FastJets_HH
 
#include "Rivet/Jet.hh"
#include "Rivet/Particle.hh"
#include "Rivet/Projection.hh"
#include "Rivet/Projections/JetFinder.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Tools/RivetFastJet.hh"
 
#include "fastjet/SISConePlugin.hh"
#include "fastjet/ATLASConePlugin.hh"
#include "fastjet/CMSIterativeConePlugin.hh"
#include "fastjet/CDFJetCluPlugin.hh"
#include "fastjet/CDFMidPointPlugin.hh"
#include "fastjet/D0RunIIConePlugin.hh"
#include "fastjet/TrackJetPlugin.hh"
#include "fastjet/JadePlugin.hh"
 
#include "Rivet/Projections/PxConePlugin.hh"
#include "Rivet/Tools/TypeTraits.hh"
 
namespace Rivet {
 
 
  class FastJets : public JetFinder {
  public:
 
    using JetFinder::operator =;
 
 
 
    FastJets(const FinalState& fsp,
             const fastjet::JetDefinition& jdef,
             JetMuons usemuons=JetMuons::ALL,
             JetInvisibles useinvis=JetInvisibles::NONE,
             fastjet::AreaDefinition* adef=nullptr)
      : JetFinder(fsp, usemuons, useinvis), _jdef(jdef), _adef(adef)
    {
      _initBase();
    }
 
    FastJets(const FinalState& fsp,
             const fastjet::JetDefinition& jdef,
             fastjet::AreaDefinition* adef,
             JetMuons usemuons=JetMuons::ALL,
             JetInvisibles useinvis=JetInvisibles::NONE)
      : FastJets(fsp, jdef, usemuons, useinvis, adef)
    {    }
 
    FastJets(const FinalState& fsp,
             fastjet::JetAlgorithm type,
             fastjet::RecombinationScheme recom, double rparameter,
             JetMuons usemuons=JetMuons::ALL,
             JetInvisibles useinvis=JetInvisibles::NONE,
             fastjet::AreaDefinition* adef=nullptr)
      : FastJets(fsp, fastjet::JetDefinition(type, rparameter, recom), usemuons, useinvis, adef)
    {    }
 
    FastJets(const FinalState& fsp,
             fastjet::JetAlgorithm type,
             fastjet::RecombinationScheme recom, double rparameter,
             fastjet::AreaDefinition* adef,
             JetMuons usemuons=JetMuons::ALL,
             JetInvisibles useinvis=JetInvisibles::NONE)
      : FastJets(fsp, type, recom, rparameter, usemuons, useinvis, adef)
    {    }
 
    FastJets(const FinalState& fsp,
             fastjet::JetDefinition::Plugin* plugin,
             JetMuons usemuons=JetMuons::ALL,
             JetInvisibles useinvis=JetInvisibles::NONE,
             fastjet::AreaDefinition* adef=nullptr)
      : FastJets(fsp, fastjet::JetDefinition(plugin), usemuons, useinvis, adef)
    {
      _plugin.reset(plugin);
    }
 
    FastJets(const FinalState& fsp,
             fastjet::JetDefinition::Plugin* plugin,
             fastjet::AreaDefinition* adef,
             JetMuons usemuons=JetMuons::ALL,
             JetInvisibles useinvis=JetInvisibles::NONE)
      : FastJets(fsp, plugin, usemuons, useinvis, adef)
    {    }
 
    FastJets(const FinalState& fsp,
             JetAlg alg, double rparameter,
             JetMuons usemuons=JetMuons::ALL,
             JetInvisibles useinvis=JetInvisibles::NONE,
             fastjet::AreaDefinition* adef=nullptr,
             double seed_threshold=1.0)
      : JetFinder(fsp, usemuons, useinvis), _adef(adef)
    {
      _initBase();
      _initJdef(alg, rparameter, seed_threshold);
    }
 
 
    RIVET_DEFAULT_PROJ_CLONE(FastJets);
 
 
 
    using Projection::operator =;
 
 
 
    static PseudoJets mkClusterInputs(const Particles& fsparticles, const Particles& tagparticles=Particles());
    static Jet mkJet(const PseudoJet& pj, const Particles& fsparticles, const Particles& tagparticles=Particles());
    static Jets mkJets(const PseudoJets& pjs, const Particles& fsparticles, const Particles& tagparticles=Particles());
 
 
 
    void reset();
 
 
 
    void useJetArea(fastjet::AreaDefinition* adef) {
      _adef.reset(adef);
    }
 
    void clearJetArea() {
      _adef.reset();
    }
 
 
 
 
    void addTrf(fastjet::Transformer* trf) {
      _trfs.push_back(shared_ptr<fastjet::Transformer>(trf));
    }
 
    template<typename TRFS, typename TRF=typename TRFS::value_type>
    typename std::enable_if<Derefable<TRF>::value, void>::type
    addTrfs(const TRFS& trfs) {
      for (auto& trf : trfs) addTrf(trf);
    }
 
    void clearTrfs() {
      _trfs.clear();
    }
 
 
 
 
    Jets _jets() const;
 
    PseudoJets pseudojets(double ptmin=0.0) const;
 
    PseudoJets pseudojetsByPt(double ptmin=0.0) const {
      return sorted_by_pt(pseudojets(ptmin));
    }
 
    PseudoJets pseudojetsByE(double ptmin=0.0) const {
      return sorted_by_E(pseudojets(ptmin));
    }
 
    PseudoJets pseudojetsByRapidity(double ptmin=0.0) const {
      return sorted_by_rapidity(pseudojets(ptmin));
    }
 
 
 
 
    const shared_ptr<fastjet::ClusterSequence> clusterSeq() const {
      return _cseq;
    }
 
    const shared_ptr<fastjet::ClusterSequenceArea> clusterSeqArea() const {
      return areaDef() ? dynamic_pointer_cast<fastjet::ClusterSequenceArea>(_cseq) : nullptr;
    }
 
    const fastjet::JetDefinition& jetDef() const {
      return _jdef;
    }
 
    const shared_ptr<fastjet::AreaDefinition> areaDef() const {
      return _adef;
    }
 
 
 
  protected:
 
    void _initBase();
    void _initJdef(JetAlg alg, double rparameter, double seed_threshold);
 
  protected:
 
    void project(const Event& e);
 
    CmpState compare(const Projection& p) const;
 
  public:
 
    void calc(const Particles& fsparticles, const Particles& tagparticles=Particles());
 
 
  protected:
 
    fastjet::JetDefinition _jdef;
 
    std::shared_ptr<fastjet::AreaDefinition> _adef;
 
    std::shared_ptr<fastjet::ClusterSequence> _cseq;
 
    std::shared_ptr<fastjet::JetDefinition::Plugin> _plugin;
 
    std::vector< std::shared_ptr<fastjet::Transformer> > _trfs;
 
    mutable std::map<int, vector<double> > _yscales;
 
    Particles _fsparticles, _tagparticles;
 
  };
 
}
 
#endif