rivet is hosted by Hepforge, IPPP Durham

Project out jets found using the FastJet package jet algorithms. More...

#include <FastJets.hh>

Inheritance diagram for FastJets:
Collaboration diagram for FastJets:

List of all members.

Public Types

enum  JetAlgName {
  KT, CAM, SISCONE, ANTIKT,
  ATLASCONE, CMSCONE, CDFJETCLU, CDFMIDPOINT,
  D0ILCONE, JADE, DURHAM, TRACKJET
}
enum  MuonsStrategy { NO_MUONS, DECAY_MUONS, ALL_MUONS }
 Enum for the treatment of muons: whether to include all, some, or none in jet-finding. More...
enum  InvisiblesStrategy { NO_INVISIBLES, DECAY_INVISIBLES, ALL_INVISIBLES }
 Enum for the treatment of invisible particles: whether to include all, some, or none in jet-finding. More...
typedef Jet entity_type
typedef Jets collection_type

Public Member Functions

void reset ()
 Reset the projection. Jet def, etc. are unchanged.
void useJetArea (fastjet::AreaDefinition *adef)
 Use provided jet area definition.
void calc (const Particles &fsparticles, const Particles &tagparticles=Particles())
 Do the calculation locally (no caching).
virtual unique_ptr< Projectionclone () const =0
 Clone on the heap.
size_t numJets (const Cut &c=Cuts::open()) const
 Number of jets passing the provided Cut.
size_t size () const
 Number of jets (without cuts).
bool empty () const
 Whether the inclusive jet collection is empty.
collection_type entities () const
 Template-usable interface common to FinalState.
bool before (const Projection &p) const
virtual const std::set< PdgIdPairbeamPairs () const
virtual std::string name () const
 Get the name of the projection.
ProjectionaddPdgIdPair (PdgId beam1, PdgId beam2)
 Add a colliding beam pair.
LoggetLog () const
 Get a Log object based on the getName() property of the calling projection object.
void setName (const std::string &name)
 Used by derived classes to set their name.
void markAsOwned () const
Constructors etc.
 FastJets (const FinalState &fsp, const fastjet::JetDefinition &jdef, JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS, JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES, fastjet::AreaDefinition *adef=nullptr)
 FastJets (const FinalState &fsp, const fastjet::JetDefinition &jdef, fastjet::AreaDefinition *adef, JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS, JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES)
 FastJets (const FinalState &fsp, fastjet::JetAlgorithm type, fastjet::RecombinationScheme recom, double rparameter, JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS, JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES, fastjet::AreaDefinition *adef=nullptr)
 FastJets (const FinalState &fsp, fastjet::JetAlgorithm type, fastjet::RecombinationScheme recom, double rparameter, fastjet::AreaDefinition *adef, JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS, JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES)
 FastJets (const FinalState &fsp, fastjet::JetDefinition::Plugin *plugin, JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS, JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES, fastjet::AreaDefinition *adef=nullptr)
 Explicitly pass in an externally-constructed plugin.
 FastJets (const FinalState &fsp, fastjet::JetDefinition::Plugin *plugin, fastjet::AreaDefinition *adef, JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS, JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES)
 Explicitly pass in an externally-constructed plugin, with reordered args for easier specification of jet area definition.
 FastJets (const FinalState &fsp, JetAlgName alg, double rparameter, JetAlg::MuonsStrategy usemuons=JetAlg::ALL_MUONS, JetAlg::InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES, fastjet::AreaDefinition *adef=nullptr, double seed_threshold=1.0)
 Convenience constructor using Rivet enums for most common jet algs (including some plugins).
 DEFAULT_RIVET_PROJ_CLONE (FastJets)
 Clone on the heap.
Access to the jets
Jets _jets () const
 Get the jets (unordered) with pT > ptmin.
PseudoJets pseudoJets (double ptmin=0.0) const
 Get the pseudo jets (unordered).
PseudoJets pseudojets (double ptmin=0.0) const
 Alias.
PseudoJets pseudoJetsByPt (double ptmin=0.0) const
 Get the pseudo jets, ordered by $ p_T $.
PseudoJets pseudojetsByPt (double ptmin=0.0) const
 Alias.
PseudoJets pseudoJetsByE (double ptmin=0.0) const
 Get the pseudo jets, ordered by $ E $.
PseudoJets pseudojetsByE (double ptmin=0.0) const
 Alias.
PseudoJets pseudoJetsByRapidity (double ptmin=0.0) const
 Get the pseudo jets, ordered by rapidity.
PseudoJets pseudojetsByRapidity (double ptmin=0.0) const
 Alias.
Jet trimJet (const Jet &input, const fastjet::Filter &trimmer) const
 Trim (filter) a jet, keeping tag and constituent info in the resulting jet.
Access to the FastJet clustering objects such as jet def, area def, and cluster
const shared_ptr
< fastjet::ClusterSequence > 
clusterSeq () const
const shared_ptr
< fastjet::ClusterSequenceArea > 
clusterSeqArea () const
const fastjet::JetDefinition & jetDef () const
 Return the jet definition.
const shared_ptr
< fastjet::AreaDefinition > 
areaDef () const
 Return the area definition.
Control the treatment of muons and invisible particles

Since MC-based jet calibration (and/or particle flow) can add back in particles that weren't seen in calorimeters/trackers.

void useMuons (MuonsStrategy usemuons=ALL_MUONS)
 Include (some) muons in jet construction.
void useInvisibles (InvisiblesStrategy useinvis=DECAY_INVISIBLES)
 Include (some) invisible particles in jet construction.
void useInvisibles (bool useinvis)
 Include (some) invisible particles in jet construction.
Access to jet objects
virtual Jets jets (const Cut &c=Cuts::open()) const
template<typename F >
Jets jets (F sorter, const Cut &c=Cuts::open()) const
template<typename F >
Jets jets (const Cut &c, F sorter) const
Jets jetsByPt (const Cut &c=Cuts::open()) const
Old jet accessors
Deprecated:
Use the versions with Cut arguments
Jets jets (double ptmin, double ptmax=MAXDOUBLE, double rapmin=-MAXDOUBLE, double rapmax=MAXDOUBLE, RapScheme rapscheme=PSEUDORAPIDITY) const
Jets jetsByPt (double ptmin) const
Old sorted jet accessors
Deprecated:
Use the versions with sorter function arguments. These will be removed in Rivet v3
Jets jetsByP (const Cut &c=Cuts::open()) const
Jets jetsByE (const Cut &c=Cuts::open()) const
Jets jetsByEt (const Cut &c=Cuts::open()) const
Projection "getting" functions
std::set< ConstProjectionPtrgetProjections () const
 Get the contained projections, including recursion.
template<typename PROJ >
const PROJ & getProjection (const std::string &name) const
const ProjectiongetProjection (const std::string &name) const
template<typename PROJ >
const PROJ & get (const std::string &name) const
Projection applying functions
template<typename PROJ >
const PROJ & applyProjection (const Event &evt, const Projection &proj) const
 Apply the supplied projection on event evt.
template<typename PROJ >
const PROJ & applyProjection (const Event &evt, const PROJ &proj) const
 Apply the supplied projection on event evt.
template<typename PROJ >
const PROJ & applyProjection (const Event &evt, const std::string &name) const
template<typename PROJ >
const PROJ & apply (const Event &evt, const Projection &proj) const
template<typename PROJ >
const PROJ & apply (const Event &evt, const PROJ &proj) const
template<typename PROJ >
const PROJ & apply (const Event &evt, const std::string &name) const

Protected Member Functions

void project (const Event &e)
 Perform the projection on the Event.
int compare (const Projection &p) const
 Compare projections.
Cmp< ProjectionmkNamedPCmp (const Projection &otherparent, const std::string &pname) const
Cmp< ProjectionmkPCmp (const Projection &otherparent, const std::string &pname) const
ProjectionHandlergetProjHandler () const
 Get a reference to the ProjectionHandler for this thread.
const Projection_applyProjection (const Event &evt, const std::string &name) const
const Projection_applyProjection (const Event &evt, const Projection &proj) const
Projection registration functions
template<typename PROJ >
const PROJ & declareProjection (const PROJ &proj, const std::string &name)
 Register a contained projection.
template<typename PROJ >
const PROJ & declare (const PROJ &proj, const std::string &name)
 Register a contained projection (user-facing version)
template<typename PROJ >
const PROJ & addProjection (const PROJ &proj, const std::string &name)
 Register a contained projection (user-facing version)
const Projection_declareProjection (const Projection &proj, const std::string &name)
 Untemplated function to do the work...

Protected Attributes

MuonsStrategy _useMuons
 Flag to determine whether or not to exclude (some) muons from the would-be constituents.
InvisiblesStrategy _useInvisibles
 Flag to determine whether or not to exclude (some) invisible particles from the would-be constituents.
bool _allowProjReg
 Flag to forbid projection registration in analyses until the init phase.

Private Member Functions

void _initBase ()
void _initJdef (JetAlgName alg, double rparameter, double seed_threshold)
Jet _mkJet (const PseudoJet &pj) const
 Function to make Rivet::Jet from fastjet::PseudoJet, including constituent and tag info.

Private Attributes

fastjet::JetDefinition _jdef
 Jet definition.
std::shared_ptr
< fastjet::AreaDefinition > 
_adef
 Pointer to user-handled area definition.
std::shared_ptr
< fastjet::ClusterSequence > 
_cseq
 Cluster sequence.
std::shared_ptr
< fastjet::JetDefinition::Plugin > 
_plugin
 FastJet external plugin.
std::map< int, vector< double > > _yscales
 Map of vectors of y scales. This is mutable so we can use caching/lazy evaluation.
std::map< int, Particle_particles
 set of particles sorted by their PT2

Friends

class Event
 Event is a friend.
class Cmp< Projection >
 The Cmp specialization for Projection is a friend.

Detailed Description

Project out jets found using the FastJet package jet algorithms.

Definition at line 26 of file FastJets.hh.


Member Typedef Documentation

typedef Jets collection_type [inherited]

Definition at line 218 of file JetAlg.hh.

typedef Jet entity_type [inherited]

Definition at line 217 of file JetAlg.hh.


Member Enumeration Documentation

enum InvisiblesStrategy [inherited]

Enum for the treatment of invisible particles: whether to include all, some, or none in jet-finding.

Enumerator:
NO_INVISIBLES 
DECAY_INVISIBLES 
ALL_INVISIBLES 

Definition at line 22 of file JetAlg.hh.

enum JetAlgName

Wrapper enum for selected FastJet jet algorithms.

Todo:
Move to JetAlg and alias here?
Enumerator:
KT 
CAM 
SISCONE 
ANTIKT 
ATLASCONE 
CMSCONE 
CDFJETCLU 
CDFMIDPOINT 
D0ILCONE 
JADE 
DURHAM 
TRACKJET 

Definition at line 31 of file FastJets.hh.

enum MuonsStrategy [inherited]

Enum for the treatment of muons: whether to include all, some, or none in jet-finding.

Enumerator:
NO_MUONS 
DECAY_MUONS 
ALL_MUONS 

Definition at line 19 of file JetAlg.hh.


Constructor & Destructor Documentation

FastJets ( const FinalState fsp,
const fastjet::JetDefinition &  jdef,
JetAlg::MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
JetAlg::InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES,
fastjet::AreaDefinition *  adef = nullptr 
) [inline]

Constructor from a FastJet JetDefinition

Warning:
The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.

Definition at line 44 of file FastJets.hh.

References FastJets::_initBase().

      : JetAlg(fsp, usemuons, useinvis), _jdef(jdef), _adef(adef)
    {
      _initBase();
    }
FastJets ( const FinalState fsp,
const fastjet::JetDefinition &  jdef,
fastjet::AreaDefinition *  adef,
JetAlg::MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
JetAlg::InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES 
) [inline]

JetDefinition-based constructor with reordered args for easier specification of jet area definition

Warning:
The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.

Definition at line 57 of file FastJets.hh.

      : FastJets(fsp, jdef, usemuons, useinvis, adef)
    {    }
FastJets ( const FinalState fsp,
fastjet::JetAlgorithm  type,
fastjet::RecombinationScheme  recom,
double  rparameter,
JetAlg::MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
JetAlg::InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES,
fastjet::AreaDefinition *  adef = nullptr 
) [inline]

Native argument constructor, using FastJet alg/scheme enums.

Warning:
The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.

Definition at line 68 of file FastJets.hh.

      : 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,
JetAlg::MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
JetAlg::InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES 
) [inline]

Native argument constructor with reordered args for easier specification of jet area definition

Warning:
The AreaDefinition pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.

Definition at line 80 of file FastJets.hh.

      : FastJets(fsp, type, recom, rparameter, usemuons, useinvis, adef)
    {    }
FastJets ( const FinalState fsp,
fastjet::JetDefinition::Plugin *  plugin,
JetAlg::MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
JetAlg::InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES,
fastjet::AreaDefinition *  adef = nullptr 
) [inline]

Explicitly pass in an externally-constructed plugin.

Warning:
Provided plugin and area definition pointers must be heap-allocated; Rivet will store/delete via a shared_ptr

Definition at line 92 of file FastJets.hh.

References FastJets::_plugin.

      : FastJets(fsp, fastjet::JetDefinition(plugin), usemuons, useinvis, adef)
    {
      _plugin.reset(plugin);
    }
FastJets ( const FinalState fsp,
fastjet::JetDefinition::Plugin *  plugin,
fastjet::AreaDefinition *  adef,
JetAlg::MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
JetAlg::InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES 
) [inline]

Explicitly pass in an externally-constructed plugin, with reordered args for easier specification of jet area definition.

Warning:
Provided plugin and area definition pointers must be heap-allocated; Rivet will store/delete via a shared_ptr

Definition at line 105 of file FastJets.hh.

      : FastJets(fsp, plugin, usemuons, useinvis, adef)
    {    }
FastJets ( const FinalState fsp,
JetAlgName  alg,
double  rparameter,
JetAlg::MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
JetAlg::InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES,
fastjet::AreaDefinition *  adef = nullptr,
double  seed_threshold = 1.0 
) [inline]

Convenience constructor using Rivet enums for most common jet algs (including some plugins).

For the built-in algs, E-scheme recombination is used. For full control of FastJet built-in jet algs, use the constructors from native-args or a plugin pointer.

Warning:
Provided area definition pointer must be heap-allocated; Rivet will store/delete via a shared_ptr

Definition at line 120 of file FastJets.hh.

References FastJets::_initBase(), and FastJets::_initJdef().

      : JetAlg(fsp, usemuons, useinvis)
    {
      _initBase();
      _initJdef(alg, rparameter, seed_threshold);
    }

Member Function Documentation

const Projection & _applyProjection ( const Event evt,
const std::string &  name 
) const [protected, inherited]

Non-templated version of string-based applyProjection, to work around header dependency issue.

Definition at line 22 of file ProjectionApplier.cc.

References Event::applyProjection(), and ProjectionApplier::getProjection().

Referenced by ProjectionApplier::applyProjection().

                                                                                  {
    return evt.applyProjection(getProjection(name));
  }
const Projection & _applyProjection ( const Event evt,
const Projection proj 
) const [protected, inherited]

Non-templated version of proj-based applyProjection, to work around header dependency issue.

Definition at line 28 of file ProjectionApplier.cc.

References Event::applyProjection().

                                                                                      {
    return evt.applyProjection(proj);
  }
const Projection & _declareProjection ( const Projection proj,
const std::string &  name 
) [protected, inherited]

Untemplated function to do the work...

Definition at line 34 of file ProjectionApplier.cc.

References ProjectionApplier::_allowProjReg, ProjectionApplier::getProjHandler(), ProjectionApplier::name(), Projection::name(), and ProjectionHandler::registerProjection().

Referenced by ProjectionApplier::declareProjection().

                                                                             {
    if (!_allowProjReg) {
      cerr << "Trying to register projection '"
           << proj.name() << "' before init phase in '" << this->name() << "'." << endl;
      exit(2);
    }
    const Projection& reg = getProjHandler().registerProjection(*this, proj, name);
    return reg;
  }
void _initBase ( ) [private]

Shared utility functions to implement constructor behaviour

Todo:
Replace with calls between constructors when C++11 available?

Definition at line 11 of file FastJets.cc.

References ProjectionApplier::addProjection(), TauFinder::HADRONIC, and Projection::setName().

Referenced by FastJets::FastJets().

                           {
    setName("FastJets");
    addProjection(HeavyHadrons(), "HFHadrons");
    addProjection(TauFinder(TauFinder::HADRONIC), "Taus");
  }
void _initJdef ( JetAlgName  alg,
double  rparameter,
double  seed_threshold 
) [private]

Definition at line 22 of file FastJets.cc.

References FastJets::_jdef, FastJets::_plugin, FastJets::ANTIKT, FastJets::ATLASCONE, FastJets::CAM, FastJets::CDFJETCLU, FastJets::CDFMIDPOINT, FastJets::CMSCONE, FastJets::D0ILCONE, FastJets::DURHAM, FastJets::JADE, FastJets::KT, MSG_DEBUG, FastJets::SISCONE, and FastJets::TRACKJET.

Referenced by FastJets::FastJets().

                                                                                   {
    MSG_DEBUG("JetAlg = " << alg);
    MSG_DEBUG("R parameter = " << rparameter);
    MSG_DEBUG("Seed threshold = " << seed_threshold);
    if (alg == KT) {
      _jdef = fastjet::JetDefinition(fastjet::kt_algorithm, rparameter, fastjet::E_scheme);
    } else if (alg == CAM) {
      _jdef = fastjet::JetDefinition(fastjet::cambridge_algorithm, rparameter, fastjet::E_scheme);
    } else if (alg == ANTIKT) {
      _jdef = fastjet::JetDefinition(fastjet::antikt_algorithm, rparameter, fastjet::E_scheme);
    } else if (alg == DURHAM) {
      _jdef = fastjet::JetDefinition(fastjet::ee_kt_algorithm, fastjet::E_scheme);
    } else {
      // Plugins:
      if (alg == SISCONE) {
        const double OVERLAP_THRESHOLD = 0.75;
        _plugin.reset(new fastjet::SISConePlugin(rparameter, OVERLAP_THRESHOLD));
      // } else if (alg == PXCONE) {
      //   string msg = "PxCone currently not supported, since FastJet doesn't install it by default. ";
      //   msg += "Please notify the Rivet authors if this behaviour should be changed.";
      //   throw Error(msg);
      //  _plugin.reset(new fastjet::PxConePlugin(rparameter));
      } else if (alg == ATLASCONE) {
        const double OVERLAP_THRESHOLD = 0.5;
        _plugin.reset(new fastjet::ATLASConePlugin(rparameter, seed_threshold, OVERLAP_THRESHOLD));
      } else if (alg == CMSCONE) {
        _plugin.reset(new fastjet::CMSIterativeConePlugin(rparameter, seed_threshold));
      } else if (alg == CDFJETCLU) {
        const double OVERLAP_THRESHOLD = 0.75;
        _plugin.reset(new fastjet::CDFJetCluPlugin(rparameter, OVERLAP_THRESHOLD, seed_threshold));
      } else if (alg == CDFMIDPOINT) {
        const double OVERLAP_THRESHOLD = 0.5;
        _plugin.reset(new fastjet::CDFMidPointPlugin(rparameter, OVERLAP_THRESHOLD, seed_threshold));
      } else if (alg == D0ILCONE) {
        const double min_jet_Et = 6.0;
        _plugin.reset(new fastjet::D0RunIIConePlugin(rparameter, min_jet_Et));
      } else if (alg == JADE) {
        _plugin.reset(new fastjet::JadePlugin());
      } else if (alg == TRACKJET) {
        _plugin.reset(new fastjet::TrackJetPlugin(rparameter));
      }
      _jdef = fastjet::JetDefinition(_plugin.get());
    }
  }
Jets _jets ( ) const [virtual]

Get the jets (unordered) with pT > ptmin.

Todo:
Cache?

Implements JetAlg.

Definition at line 183 of file FastJets.cc.

References FastJets::_mkJet(), FastJets::pseudojets(), and JetAlg::size().

                             {
    Jets rtn; rtn.reserve(pseudojets().size());
    foreach (const fastjet::PseudoJet& pj, pseudojets()) {
      rtn.push_back(_mkJet(pj));
    }
    /// @todo Cache?
    return rtn;
  }
Jet _mkJet ( const PseudoJet &  pj) const [private]

Function to make Rivet::Jet from fastjet::PseudoJet, including constituent and tag info.

Definition at line 205 of file FastJets.cc.

References FastJets::_particles, and FastJets::clusterSeq().

Referenced by FastJets::_jets(), and FastJets::trimJet().

                                              {
    assert(clusterSeq());

    // Take the constituents from the cluster sequence, unless the jet was not
    // associated with the cluster sequence (could be the case for trimmed jets)
    const PseudoJets parts = (pj.associated_cluster_sequence() == clusterSeq().get())
      ? clusterSeq()->constituents(pj) : pj.constituents();

    vector<Particle> constituents, tags;
    constituents.reserve(parts.size());
    for (const fastjet::PseudoJet& p : parts) {
      map<int, Particle>::const_iterator found = _particles.find(p.user_index());
      // assert(found != _particles.end());
      if (found == _particles.end() && p.is_pure_ghost()) continue; //< Pure FJ ghosts are ok
      assert(found != _particles.end()); //< Anything else must be known
      assert(found->first != 0); //< All mapping IDs are pos-def (particles) or neg-def (tags)
      if (found->first > 0) constituents.push_back(found->second);
      else if (found->first < 0) tags.push_back(found->second);
    }

    return Jet(pj, constituents, tags);
  }
Projection& addPdgIdPair ( PdgId  beam1,
PdgId  beam2 
) [inline, inherited]

Add a colliding beam pair.

Definition at line 108 of file Projection.hh.

References Projection::_beamPairs.

Referenced by Projection::Projection().

                                                       {
      _beamPairs.insert(PdgIdPair(beam1, beam2));
      return *this;
    }
const PROJ& addProjection ( const PROJ &  proj,
const std::string &  name 
) [inline, protected, inherited]

Register a contained projection (user-facing version)

Deprecated:
Use declareProjection() or declare()
Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 157 of file ProjectionApplier.hh.

References ProjectionApplier::declareProjection().

Referenced by FastJets::_initBase(), VetoedFinalState::addVetoOnThisFinalState(), BeamThrust::BeamThrust(), CentralEtHCM::CentralEtHCM(), ChargedFinalState::ChargedFinalState(), ChargedLeptons::ChargedLeptons(), DISFinalState::DISFinalState(), DISKinematics::DISKinematics(), DISLepton::DISLepton(), DressedLeptons::DressedLeptons(), FinalState::FinalState(), FoxWolframMoments::FoxWolframMoments(), FParameter::FParameter(), HadronicFinalState::HadronicFinalState(), HeavyHadrons::HeavyHadrons(), Hemispheres::Hemispheres(), IdentifiedFinalState::IdentifiedFinalState(), ATLAS_2016_I1468168::init(), ATLAS_2015_I1393758::init(), ATLAS_2016_I1419070::init(), ATLAS_2016_I1457605::init(), CMS_2015_I1397174::init(), CMS_2016_I1473674::init(), JetAlg::JetAlg(), JetShape::JetShape(), LeadingParticlesFinalState::LeadingParticlesFinalState(), LossyFinalState< ConstRandomFilter >::LossyFinalState(), MergedFinalState::MergedFinalState(), MissingMomentum::MissingMomentum(), NeutralFinalState::NeutralFinalState(), NonHadronicFinalState::NonHadronicFinalState(), NonPromptFinalState::NonPromptFinalState(), ParisiTensor::ParisiTensor(), PrimaryHadrons::PrimaryHadrons(), PromptFinalState::PromptFinalState(), SmearedJets::SmearedJets(), SmearedMET::SmearedMET(), SmearedParticles::SmearedParticles(), Sphericity::Sphericity(), Spherocity::Spherocity(), TauFinder::TauFinder(), Thrust::Thrust(), TriggerCDFRun0Run1::TriggerCDFRun0Run1(), TriggerCDFRun2::TriggerCDFRun2(), TriggerUA5::TriggerUA5(), VetoedFinalState::VetoedFinalState(), VisibleFinalState::VisibleFinalState(), WFinder::WFinder(), and ZFinder::ZFinder().

{ return declareProjection(proj, name); }
const PROJ& apply ( const Event evt,
const Projection proj 
) const [inline, inherited]

Apply the supplied projection on event evt (user-facing alias).

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 80 of file ProjectionApplier.hh.

{ return applyProjection<PROJ>(evt, proj); }
const PROJ& apply ( const Event evt,
const PROJ &  proj 
) const [inline, inherited]

Apply the supplied projection on event evt (user-facing alias).

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 92 of file ProjectionApplier.hh.

{ return applyProjection<PROJ>(evt, proj); }
const PROJ& apply ( const Event evt,
const std::string &  name 
) const [inline, inherited]

Apply the supplied projection on event evt (user-facing alias).

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 104 of file ProjectionApplier.hh.

References ProjectionApplier::name().

{ return applyProjection<PROJ>(evt, name); }
const PROJ& applyProjection ( const Event evt,
const Projection proj 
) const [inline, inherited]

Apply the supplied projection on event evt.

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 74 of file ProjectionApplier.hh.

References ProjectionApplier::_applyProjection().

Referenced by DISFinalState::project().

                                                                                {
      return pcast<PROJ>(_applyProjection(evt, proj));
    }
const PROJ& applyProjection ( const Event evt,
const PROJ &  proj 
) const [inline, inherited]

Apply the supplied projection on event evt.

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 86 of file ProjectionApplier.hh.

References ProjectionApplier::_applyProjection().

                                                                          {
      return pcast<PROJ>(_applyProjection(evt, proj));
    }
const PROJ& applyProjection ( const Event evt,
const std::string &  name 
) const [inline, inherited]

Apply the named projection on event evt.

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 98 of file ProjectionApplier.hh.

References ProjectionApplier::_applyProjection().

                                                                               {
      return pcast<PROJ>(_applyProjection(evt, name));
    }
const shared_ptr<fastjet::AreaDefinition> areaDef ( ) const [inline]

Return the area definition.

Warning:
May be null!
Todo:
Care needed re. const shared_ptr<T> vs. shared_ptr<const T>

Definition at line 234 of file FastJets.hh.

References FastJets::_adef.

Referenced by FastJets::clusterSeqArea().

                                                            {
      return _adef;
    }
const set< PdgIdPair > beamPairs ( ) const [virtual, inherited]

Return the allowed beam pairs on which this projection can operate, not including recursion. Derived classes should ensure that all contained projections are registered in the _projections set for the beam constraint chaining to work.

Todo:
Remove the beam constraints system from projections.

Definition at line 35 of file Projection.cc.

References Projection::_beamPairs, Projection::beamPairs(), Projection::getLog(), ProjectionApplier::getProjections(), Rivet::intersection(), Rivet::p(), and Log::TRACE.

Referenced by Projection::beamPairs().

                                                   {
    set<PdgIdPair> ret = _beamPairs;
    set<ConstProjectionPtr> projs = getProjections();
    for (set<ConstProjectionPtr>::const_iterator ip = projs.begin(); ip != projs.end(); ++ip) {
      ConstProjectionPtr p = *ip;
      getLog() << Log::TRACE << "Proj addr = " << p << endl;
      if (p) ret = intersection(ret, p->beamPairs());
    }
    return ret;
  }
bool before ( const Projection p) const [inherited]

Determine whether this object should be ordered before the object p given as argument. If p is of a different class than this, the before() function of the corresponding type_info objects is used. Otherwise, if the objects are of the same class, the virtual compare(const Projection &) will be returned.

Definition at line 24 of file Projection.cc.

References Projection::compare(), and Rivet::p().

Referenced by less< const Rivet::Projection * >::operator()().

                                                   {
    const std::type_info& thisid = typeid(*this);
    const std::type_info& otherid = typeid(p);
    if (thisid == otherid) {
      return compare(p) < 0;
    } else {
      return thisid.before(otherid);
    }
  }
void calc ( const Particles fsparticles,
const Particles tagparticles = Particles() 
)

Do the calculation locally (no caching).

Todo:
Use FastJet3's UserInfo system

< Ghostify the momentum

Definition at line 136 of file FastJets.cc.

References FastJets::_adef, FastJets::_cseq, FastJets::_jdef, FastJets::_particles, Rivet::GeV, MSG_DEBUG, and Rivet::p().

Referenced by FastJets::project().

                                                                                 {
    _particles.clear();
    vector<fastjet::PseudoJet> pjs;

    MSG_DEBUG("Finding jets from " << fsparticles.size() << " input particles");

    /// @todo Use FastJet3's UserInfo system

    // Store 4 vector data about each particle into FastJet's PseudoJets
    int counter = 1;
    for (const Particle& p : fsparticles) {
      fastjet::PseudoJet pj = p;
      pj.set_user_index(counter);
      pjs.push_back(pj);
      _particles[counter] = p;
      counter += 1;
    }
    // And the same for ghost tagging particles (with negative user indices)
    counter = 1;
    for (const Particle& p : tagparticles) {
      fastjet::PseudoJet pj = p;
      pj *= 1e-20; ///< Ghostify the momentum
      pj.set_user_index(-counter);
      pjs.push_back(pj);
      _particles[-counter] = p;
      counter += 1;
    }

    // Choose cseq as basic or area-calculating
    if (_adef) {
      _cseq.reset(new fastjet::ClusterSequenceArea(pjs, _jdef, *_adef));
    } else {
      _cseq.reset(new fastjet::ClusterSequence(pjs, _jdef));
    }
    MSG_DEBUG("FastJet ClusterSequence constructed; Njets_tot = "
              << _cseq->inclusive_jets().size() << ", Njets_10 = "
              << _cseq->inclusive_jets(10*GeV).size()); //< only inefficient in debug mode
  }
virtual unique_ptr<Projection> clone ( ) const [pure virtual, inherited]

Clone on the heap.

Implements Projection.

const shared_ptr<fastjet::ClusterSequenceArea> clusterSeqArea ( ) const [inline]

Return the area-enabled cluster sequence (if an area defn exists, otherwise returns a null ptr).

Todo:
Care needed re. const shared_ptr<T> vs. shared_ptr<const T>

Definition at line 218 of file FastJets.hh.

References FastJets::_cseq, and FastJets::areaDef().

                                                                        {
      return areaDef() ? dynamic_pointer_cast<fastjet::ClusterSequenceArea>(_cseq) : nullptr;
    }
int compare ( const Projection p) const [protected, virtual]

Compare projections.

Implements JetAlg.

Definition at line 92 of file FastJets.cc.

References FastJets::_adef, FastJets::_jdef, JetAlg::_useInvisibles, JetAlg::_useMuons, Rivet::cmp(), Projection::mkNamedPCmp(), and Rivet::p().

                                                 {
    const FastJets& other = dynamic_cast<const FastJets&>(p);
    return \
      cmp(_useMuons, other._useMuons) ||
      cmp(_useInvisibles, other._useInvisibles) ||
      mkNamedPCmp(other, "FS") ||
      cmp(_jdef.jet_algorithm(), other._jdef.jet_algorithm()) ||
      cmp(_jdef.recombination_scheme(), other._jdef.recombination_scheme()) ||
      cmp(_jdef.plugin(), other._jdef.plugin()) ||
      cmp(_jdef.R(), other._jdef.R()) ||
      cmp(_adef, other._adef);
  }
const PROJ& declare ( const PROJ &  proj,
const std::string &  name 
) [inline, protected, inherited]

Register a contained projection (user-facing version)

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 151 of file ProjectionApplier.hh.

References ProjectionApplier::declareProjection().

Referenced by CDF_2009_S8057893::CDF_2009_S8057893::init(), ATLAS_2010_S8894728::init(), CMS_2010_S8656010::init(), CMS_2010_S8547297::init(), ALICE_2012_I1181770::init(), CMS_2015_I1327224::init(), CMS_2011_S8950903::init(), CMS_2012_PAS_QCD_11_010::init(), CMS_2015_I1356998::init(), ATLAS_2011_S8994773::init(), CMS_2012_I1090423::init(), CMS_2012_I1184941::init(), CMSTOTEM_2014_I1294140::init(), TOTEM_2012_I1220862::init(), ATLAS_2015_I1387176::init(), LHCB_2013_I1208105::init(), ATLAS_2010_CONF_2010_049::init(), CMS_2011_S8941262::init(), CMS_2011_S8973270::init(), CMS_2011_S8968497::init(), ATLAS_2014_I1298811::init(), CMS_2012_I1193338::init(), ALICE_2014_I1300380::init(), ALICE_2011_S8909580::init(), ATLAS_2011_I894867::init(), CMS_2015_I1384119::init(), BABAR_2005_S6181155::init(), CDF_2007_S7057202::init(), TOTEM_2012_I1115294::init(), TOTEM_2014_I1328627::init(), ALICE_2015_I1357424::init(), CMS_2011_S9086218::init(), CMS_2012_I1087342::init(), CMS_2011_S9215166::init(), ATLAS_2014_I1282441::init(), ATLAS_2014_I1315949::init(), ALICE_2011_S8945144::init(), ATLAS_2012_I1091481::init(), ATLAS_2015_I1404878::init(), ARGUS_1993_S2789213::init(), BABAR_2007_S6895344::init(), LHCF_2012_I1115479::init(), MC_ELECTRONS::init(), BABAR_2013_I1238276::init(), MC_JETTAGS::init(), ATLAS_2011_I930220::init(), BELLE_2001_S4598261::init(), MC_MUONS::init(), MC_TAUS::init(), SFM_1984_S1178091::init(), ATLAS_2010_S8591806::init(), ATLAS_2011_S9002537::init(), CMS_2011_I954992::init(), CMS_2011_S8957746::init(), CMS_2011_S8978280::init(), CMS_2011_S9088458::init(), CMS_2013_I1122847::init(), CMS_2013_I1265659::init(), CMS_2015_I1346843::init(), ATLAS_2015_I1390114::init(), D0_2011_I895662::init(), ATLAS_2011_I925932::init(), EXAMPLE_CUTS::init(), ATLAS_2016_I1452559::init(), BABAR_2013_I1116411::init(), BABAR_2015_I1334693::init(), BELLE_2008_I786560::init(), MC_MET::init(), BELLE_2011_I878990::init(), BELLE_2013_I1238273::init(), BELLE_2015_I1397632::init(), ATLAS_2012_I1188891::init(), CDF_2012_NOTE10874::init(), ATLAS_2010_S8914702::init(), CMS_2013_I1208923::init(), CMS_2013_I1273574::init(), D0_2010_S8570965::init(), ATLAS_2015_I1397635::init(), ATLAS_2015_I1408516::init(), ATLAS_2016_I1424838::init(), BABAR_2007_S7266081::init(), ATLAS_2012_I1124167::init(), STAR_2006_S6500200::init(), STAR_2008_S7993412::init(), UA5_1987_S1640666::init(), CMS_2013_I1256943::init(), CMS_2015_I1310737::init(), CMS_QCD_10_024::init(), ATLAS_2011_I921594::init(), ATLAS_2015_I1394679::init(), ATLAS_2015_I1397637::init(), MC_HINC::init(), MC_JETS::init(), MC_KTSPLITTINGS::init(), CDF_1993_S2742446::init(), CDF_1997_S3541940::init(), CDF_2000_S4155203::init(), OPAL_2003_I599181::init(), CDF_2005_S6080774::init(), CDF_2006_S6450792::init(), ALEPH_1995_I382179::init(), ATLAS_2011_S9128077::init(), CMS_2013_I1258128::init(), CMS_2013_I1261026::init(), CMS_2014_I1298810::init(), ATLAS_2014_I1319490::init(), D0_1995_I398175::init(), D0_2000_S4480767::init(), EXAMPLE::init(), LHCB_2012_I1208102::init(), MC_HJETS::init(), MC_WWINC::init(), MC_ZZINC::init(), STAR_2006_S6870392::init(), ATLAS_2012_I1204447::init(), UA5_1982_S875503::init(), CDF_2008_S8093652::init(), UA5_1989_S1926373::init(), ATLAS_2013_I1190187::init(), ATLAS_2013_I1244522::init(), CMS_2012_I1107658::init(), CDF_2008_S7782535::init(), CMS_2013_I1209721::init(), CMS_2015_I1385107::init(), ATLAS_2014_I1307756::init(), D0_2008_S6879055::init(), ATLAS_2012_I1204784::init(), ATLAS_2013_I1216670::init(), ATLAS_2011_S9035664::init(), ATLAS_2013_I1219109::init(), ATLAS_2013_I1243871::init(), CMS_2012_I1102908::init(), ATLAS_2014_I1268975::init(), CMS_2013_I1272853::init(), ATLAS_2014_I1325553::init(), D0_2000_I499943::init(), ATLAS_2014_I1327229::init(), ATLAS_2015_I1345452::init(), ATLAS_2015_I1376945::init(), DELPHI_2011_I890503::init(), E735_1998_S3905616::init(), L3_1992_I336180::init(), ATLAS_2016_I1444991::init(), ATLAS_2011_I928289_W::init(), MC_DIPHOTON::init(), MC_HHJETS::init(), ATLAS_2011_I928289_Z::init(), ALEPH_1991_S2435284::init(), ATLAS_2011_I944826::init(), ARGUS_1993_S2669951::init(), MC_WWKTSPLITTINGS::init(), MC_ZZJETS::init(), MC_ZZKTSPLITTINGS::init(), OPAL_1993_I342766::init(), ATLAS_2012_I1183818::init(), PDG_TAUS::init(), EXAMPLE_SMEAR::init(), MC_HKTSPLITTINGS::init(), MC_ZKTSPLITTINGS::init(), MC_PHOTONINC::init(), CDF_1988_S1865951::init(), CDF_1990_S2089246::init(), MC_ZINC::init(), OPAL_1995_S3198391::init(), OPAL_1996_S3257789::init(), OPAL_1997_S3608263::init(), OPAL_1998_S3702294::init(), OPAL_1998_S3749908::init(), ATLAS_2011_S8924791::init(), OPAL_2000_S4418603::init(), CDF_2005_S6217184::init(), D0_2007_S7075677::init(), D0_2009_S8202443::init(), ATLAS_2015_I1364361::init(), D0_2010_S8821313::init(), DELPHI_1999_S3960137::init(), MC_WKTSPLITTINGS::init(), ATLAS_2010_S8817804::init(), ATLAS_2011_S9120807::init(), D0_1996_S3324664::init(), UA5_1986_S1583476::init(), ALEPH_1996_S3196992::init(), ALEPH_2002_S4823664::init(), ATLAS_2011_I954993::init(), MC_PHOTONJETS::init(), MC_PHOTONKTSPLITTINGS::init(), CDF_1994_S2952106::init(), MC_WINC::init(), MC_ZJETS::init(), MC_WWJETS::init(), MC_IDENTIFIED::init(), ATLAS_2012_I1199269::init(), ATLAS_2011_I945498::init(), D0_1996_S3214044::init(), D0_2008_S7554427::init(), D0_2008_S7863608::init(), D0_2010_S8671338::init(), ATLAS_2012_CONF_2012_104::init(), CDF_2008_S7540469::init(), ATLAS_2012_I1093738::init(), H1_1995_S3167097::init(), ATLAS_2012_I1119557::init(), LHCB_2011_I919315::init(), UA1_1990_S2044935::init(), ATLAS_2016_I1458270::init(), MC_LEADJETUE::init(), ATLAS_2012_I1180197::init(), MC_WJETS::init(), CDF_2008_S7828950::init(), D0_2001_S4674421::init(), ATLAS_2011_S9131140::init(), ATLAS_2014_I1300647::init(), ATLAS_2011_S9212353::init(), ATLAS_2014_I1306615::init(), MC_TTBAR::init(), ATLAS_2012_CONF_2012_105::init(), D0_2008_S7837160::init(), MC_GENERIC::init(), ATLAS_2015_I1351916::init(), ATLAS_2012_I1095236::init(), ATLAS_2011_I926145::init(), ALEPH_2004_S5765862::init(), JADE_1998_S3612880::init(), STAR_2009_UE_HELEN::init(), ATLAS_2011_S8983313::init(), ZEUS_2001_S4815815::init(), ATLAS_2013_I1217863_W::init(), ATLAS_2013_I1217863_Z::init(), OPAL_1997_S3396100::init(), ATLAS_2012_I1126136::init(), MC_QCD_PARTONS::init(), ATLAS_2012_CONF_2012_109::init(), CMS_2012_I941555::init(), CDF_2008_S8095620::init(), DELPHI_1995_S3137023::init(), H1_2000_S4129130::init(), STAR_2006_S6860818::init(), ATLAS_2012_I1186556::init(), ATLAS_2012_CONF_2012_103::init(), CMS_2014_I1303894::init(), ATLAS_2011_CONF_2011_098::init(), ALEPH_1999_S4193598::init(), JADE_OPAL_2000_S4300807::init(), ALICE_2010_S8624100::init(), ATLAS_2011_S9212183::init(), ATLAS_2012_I1125961::init(), ATLAS_2014_I1307243::init(), LHCB_2013_I1218996::init(), ATLAS_2014_I1288706::init(), CMS_2013_I1218372::init(), ATLAS_2012_I1190891::init(), ATLAS_2012_CONF_2012_001::init(), ALICE_2010_S8625980::init(), MC_HFJETS::init(), ALICE_2010_S8706239::init(), ATLAS_2012_I1112263::init(), ATLAS_2012_I1125575::init(), CDF_2009_NOTE_9936::init(), CDF_1996_S3108457::init(), UA5_1988_S1867512::init(), D0_2009_S8320160::init(), CDF_2001_S4563131::init(), ATLAS_2011_S8971293::init(), CDF_2009_I856131::init(), D0_2009_S8349509::init(), ATLAS_2016_I1426695::init(), CDF_1996_S3349578::init(), CDF_2009_S8436959::init(), ATLAS_2014_I1298023::init(), CDF_1998_S3618439::init(), MC_SUSY::init(), CDF_2000_S4266730::init(), ATLAS_2013_I1230812::init(), CDF_2001_S4517016::init(), ATLAS_2015_CONF_2015_041::init(), MC_VH2BB::init(), ATLAS_2010_S8919674::init(), ALEPH_2001_S4656318::init(), MC_WPOL::init(), ATLAS_2012_I1082936::init(), D0_2010_S8566488::init(), SLD_2002_S4869273::init(), DELPHI_2002_069_CONF_603::init(), D0_2006_S6438750::init(), CDF_1996_S3418421::init(), LHCB_2014_I1281685::init(), LHCB_2012_I1119400::init(), SLD_1996_S3398250::init(), ATLAS_2014_I1326641::init(), LHCB_2011_I917009::init(), MC_PHOTONS::init(), ATLAS_2014_I1306294::init(), ATLAS_2011_S9108483::init(), CDF_2008_S7541902::init(), ATLAS_2014_I1304688::init(), CDF_2006_S6653332::init(), D0_2008_S7662670::init(), H1_1994_S2919893::init(), ATLAS_2011_S9019561::init(), ATLAS_2012_I943401::init(), ATLAS_2012_I1117704::init(), ATLAS_2012_I1082009::init(), ATLAS_2011_S9225137::init(), ATLAS_2011_CONF_2011_090::init(), TASSO_1990_S2148048::init(), ATLAS_2012_I946427::init(), DELPHI_2000_S4328825::init(), OPAL_2002_S5361494::init(), ATLAS_2012_I1084540::init(), ATLAS_2012_CONF_2012_153::init(), CMS_2013_I1224539_DIJET::init(), CMS_2013_I1224539_WJET::init(), ATLAS_2012_I1083318::init(), ATLAS_2013_I1217867::init(), CDF_2009_S8233977::init(), CMS_2013_I1224539_ZJET::init(), CDF_2010_S8591881_DY::init(), CDF_2010_S8591881_QCD::init(), CDF_2001_S4751469::init(), ATLAS_2016_I1419652::init(), D0_2004_S5992206::init(), ATLAS_2014_I1312627::init(), ATLAS_2010_S8918562::init(), D0_2008_S7719523::init(), ATLAS_2012_I1094568::init(), ATLAS_2011_S9041966::init(), DELPHI_1996_S3430090::init(), ALEPH_1996_S3486095::init(), OPAL_2004_S6132243::init(), OPAL_1994_S2927284::init(), BELLE_2013_I1216515::init(), STAR_2008_S7869363::init(), ATLAS_2011_S9126244::init(), ATLAS_2011_I919017::init(), OPAL_2001_S4553896::init(), ATLAS_2012_I1203852::init(), CDF_2004_S5839831::init(), BABAR_2003_I593379::init(), CMS_2015_I1370682::init(), ARGUS_1993_S2653028::init(), ATLAS_2012_I1094061::init(), CLEO_2004_S5809304::init(), CMS_2014_I1305624::init(), OPAL_1998_S3780481::init(), ATLAS_2012_I1093734::init(), OPAL_1993_S2692198::init(), ATLAS_2014_I1279489::init(), ATLAS_2014_I1282447::init(), ATLAS_2012_I1094564::init(), SLD_2004_S5693039::init(), SLD_1999_S3743934::init(), PDG_HADRON_MULTIPLICITIES::init(), and PDG_HADRON_MULTIPLICITIES_RATIOS::init().

{ return declareProjection(proj, name); }
const PROJ& declareProjection ( const PROJ &  proj,
const std::string &  name 
) [inline, protected, inherited]

Register a contained projection.

The type of the argument is used to instantiate a new projection internally: this new object is applied to events rather than the argument object. Hence you are advised to only use locally-scoped Projection objects in your Projection and Analysis constructors, and to avoid polymorphism (e.g. handling ConcreteProjection via a pointer or reference to type Projection) since this will screw up the internal type management.

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 142 of file ProjectionApplier.hh.

References ProjectionApplier::_declareProjection().

Referenced by ProjectionApplier::addProjection(), and ProjectionApplier::declare().

                                                                           {
      const Projection& reg = _declareProjection(proj, name);
      const PROJ& rtn = dynamic_cast<const PROJ&>(reg);
      return rtn;
    }

Clone on the heap.

bool empty ( ) const [inline, inherited]

Whether the inclusive jet collection is empty.

Definition at line 212 of file JetAlg.hh.

References JetAlg::size().

{ return size() != 0; }
collection_type entities ( ) const [inline, inherited]

Template-usable interface common to FinalState.

Definition at line 221 of file JetAlg.hh.

References JetAlg::jets().

{ return jets(); }
const PROJ& get ( const std::string &  name) const [inline, inherited]

Get the named projection, specifying return type via a template argument (user-facing alias).

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 57 of file ProjectionApplier.hh.

References ProjectionApplier::name().

Referenced by ProjectionHandler::_register().

{ return getProjection<PROJ>(name); }
Log& getLog ( ) const [inline, inherited]

Get a Log object based on the getName() property of the calling projection object.

Reimplemented from ProjectionApplier.

Definition at line 115 of file Projection.hh.

References Projection::name().

Referenced by Projection::beamPairs(), InvMassFinalState::calc(), ChargedFinalState::project(), InitialQuarks::project(), NonPromptFinalState::project(), PromptFinalState::project(), LossyFinalState< ConstRandomFilter >::project(), UnstableFinalState::project(), and VetoedFinalState::project().

                        {
      string logname = "Rivet.Projection." + name();
      return Log::getLog(logname);
    }
const PROJ& getProjection ( const std::string &  name) const [inline, inherited]

Get the named projection, specifying return type via a template argument.

Todo:
Add SFINAE to require that PROJ inherit from Projection

Definition at line 50 of file ProjectionApplier.hh.

References ProjectionHandler::getProjection(), ProjectionApplier::getProjHandler(), and Rivet::p().

Referenced by ProjectionApplier::_applyProjection(), Rivet::pcmp(), and Hemispheres::project().

                                                           {
      const Projection& p = getProjHandler().getProjection(*this, name);
      return pcast<PROJ>(p);
    }
const Projection& getProjection ( const std::string &  name) const [inline, inherited]

Get the named projection (non-templated, so returns as a reference to a Projection base class).

Definition at line 61 of file ProjectionApplier.hh.

References ProjectionHandler::getProjection(), and ProjectionApplier::getProjHandler().

                                                                 {
      return getProjHandler().getProjection(*this, name);
    }
std::set<ConstProjectionPtr> getProjections ( ) const [inline, inherited]

Get the contained projections, including recursion.

Definition at line 43 of file ProjectionApplier.hh.

References ProjectionHandler::DEEP, ProjectionHandler::getChildProjections(), and ProjectionApplier::getProjHandler().

Referenced by Projection::beamPairs().

const fastjet::JetDefinition& jetDef ( ) const [inline]

Return the jet definition.

Definition at line 226 of file FastJets.hh.

References FastJets::_jdef.

                                               {
      return _jdef;
    }
virtual Jets jets ( const Cut c = Cuts::open()) const [inline, virtual, inherited]

Get jets in no guaranteed order, with optional cuts on $ p_\perp $ and rapidity.

Note:
Returns a copy rather than a reference, due to cuts

Definition at line 85 of file JetAlg.hh.

References JetAlg::_jets(), and Rivet::filterBy().

Referenced by CMS_2012_I1087342::analyze(), CMS_2011_S9086218::analyze(), CMS_2012_I1102908::analyze(), CDF_2008_S7782535::analyze(), D0_2008_S7662670::analyze(), CDF_2008_S7541902::analyze(), ATLAS_2013_I1217863_Z::analyze(), ATLAS_2013_I1217863_W::analyze(), JetAlg::entities(), JetAlg::jets(), JetAlg::jetsByE(), JetAlg::jetsByEt(), JetAlg::jetsByP(), JetAlg::jetsByPt(), JetAlg::numJets(), and JetAlg::size().

                                                     {
      return filterBy(_jets(), c);
      // const Jets rawjets = _jets();
      // // Just return a copy of rawjets if the cut is open
      // if (c == Cuts::open()) return rawjets;
      // // If there is a non-trivial cut...
      // /// @todo Use an STL erase(remove_if) and lambda function for this
      // Jets rtn;
      // rtn.reserve(size());
      // foreach (const Jet& j, rawjets)
      //   if (c->accept(j)) rtn.push_back(j);
      // return rtn;
    }
Jets jets ( sorter,
const Cut c = Cuts::open() 
) const [inline, inherited]
Todo:
Want to add a general filtering function, but that clashes with the sorting functor... SFINAE?

Get the jets, ordered by supplied sorting function object, with optional cuts on $ p_\perp $ and rapidity.

Note:
Returns a copy rather than a reference, due to cuts and sorting
Todo:
Will the vector be efficiently std::move'd by value through this function chain?

Definition at line 106 of file JetAlg.hh.

References JetAlg::jets(), and Rivet::sortBy().

                                                       {
      /// @todo Will the vector be efficiently std::move'd by value through this function chain?
      return sortBy(jets(c), sorter);
    }
Jets jets ( const Cut c,
sorter 
) const [inline, inherited]

Get the jets, ordered by supplied sorting function object, with optional cuts on $ p_\perp $ and rapidity.

Note:
Returns a copy rather than a reference, due to cuts and sorting
Todo:
Will the vector be efficiently std::move'd by value through this function chain?

Definition at line 114 of file JetAlg.hh.

References JetAlg::jets(), and Rivet::sortBy().

                                            {
      /// @todo Will the vector be efficiently std::move'd by value through this function chain?
      return sortBy(jets(c), sorter);
    }
Jets jets ( double  ptmin,
double  ptmax = MAXDOUBLE,
double  rapmin = -MAXDOUBLE,
double  rapmax = MAXDOUBLE,
RapScheme  rapscheme = PSEUDORAPIDITY 
) const [inline, inherited]

Get jets in no guaranteed order, with optional cuts on $ p_\perp $ and rapidity.

Deprecated:
Use the version with a Cut argument
Note:
Returns a copy rather than a reference, due to cuts

Definition at line 173 of file JetAlg.hh.

References Rivet::Cuts::etaIn(), JetAlg::jets(), Rivet::Cuts::pT, Rivet::RAPIDITY, and Rivet::Cuts::rapIn().

                                                        {
      if (rapscheme == PSEUDORAPIDITY) {
        return jets((Cuts::pT >= ptmin) & (Cuts::pT < ptmax) & (Cuts::rapIn(rapmin, rapmax)));
      } else if (rapscheme == RAPIDITY) {
        return jets((Cuts::pT >= ptmin) & (Cuts::pT < ptmax) & (Cuts::etaIn(rapmin, rapmax)));
      }
      throw LogicError("Unknown rapidity scheme. This shouldn't be possible!");
    }
Jets jetsByE ( const Cut c = Cuts::open()) const [inline, inherited]

Get the jets, ordered by $ E $, with optional cuts on $ p_\perp $ and rapidity.

Note:
Returns a copy rather than a reference, due to cuts and sorting
Deprecated:
Use the version with a sorter function argument.

Definition at line 149 of file JetAlg.hh.

References Rivet::cmpMomByE(), and JetAlg::jets().

                                                {
      return jets(c, cmpMomByE);
    }
Jets jetsByEt ( const Cut c = Cuts::open()) const [inline, inherited]

Get the jets, ordered by $ E_T $, with optional cuts on $ p_\perp $ and rapidity.

Note:
Returns a copy rather than a reference, due to cuts and sorting
Deprecated:
Use the version with a sorter function argument.

Definition at line 157 of file JetAlg.hh.

References Rivet::cmpMomByEt(), and JetAlg::jets().

                                                 {
      return jets(c, cmpMomByEt);
    }
Jets jetsByP ( const Cut c = Cuts::open()) const [inline, inherited]

Get the jets, ordered by $ |p| $, with optional cuts on $ p_\perp $ and rapidity.

Note:
Returns a copy rather than a reference, due to cuts and sorting
Deprecated:
Use the version with a sorter function argument.

Definition at line 141 of file JetAlg.hh.

References Rivet::cmpMomByP(), and JetAlg::jets().

                                                {
      return jets(c, cmpMomByP);
    }
Jets jetsByPt ( double  ptmin) const [inline, inherited]

Get the jets, ordered by $ p_T $, with a cut on $ p_\perp $.

Deprecated:
Use the version with a Cut argument
Note:
Returns a copy rather than a reference, due to cuts and sorting

This is a very common use-case, so is available as syntatic sugar for jets(Cuts::pT >= ptmin, cmpMomByPt).

Todo:
The other sorted accessors should be removed in a cleanup.

Definition at line 191 of file JetAlg.hh.

References Rivet::cmpMomByPt(), JetAlg::jets(), and Rivet::Cuts::pT.

                                      {
      return jets(Cuts::pT >= ptmin, cmpMomByPt);
    }
void markAsOwned ( ) const [inline, inherited]

Mark object as owned by the _projhandler

Todo:
Huh? What's this for?

Definition at line 111 of file ProjectionApplier.hh.

References ProjectionApplier::_owned.

{ _owned = true; }
Cmp< Projection > mkPCmp ( const Projection otherparent,
const std::string &  pname 
) const [protected, inherited]

Shortcut to make a named Cmp<Projection> comparison with the *this object automatically passed as one of the parent projections.

Note:
Alias for mkNamedPCmp

Definition at line 51 of file Projection.cc.

References Rivet::pcmp().

Referenced by SmearedMET::compare(), SmearedParticles::compare(), and SmearedJets::compare().

                                                                                             {
    return pcmp(*this, otherparent, pname);
  }
size_t numJets ( const Cut c = Cuts::open()) const [inline, inherited]

Number of jets passing the provided Cut.

Definition at line 207 of file JetAlg.hh.

References JetAlg::jets().

{ return jets(c).size(); }
void project ( const Event e) [protected, virtual]

Perform the projection on the Event.

Todo:
Allow the user to specify tag particle kinematic thresholds

Implements JetAlg.

Definition at line 114 of file FastJets.cc.

References JetAlg::_useInvisibles, JetAlg::_useMuons, FastJets::calc(), JetAlg::DECAY_INVISIBLES, JetAlg::DECAY_MUONS, Rivet::PID::isMuon(), JetAlg::NO_INVISIBLES, JetAlg::NO_MUONS, and Rivet::particles().

                                       {
    // Assemble final state particles
    const string fskey = (_useInvisibles == JetAlg::NO_INVISIBLES) ? "VFS" : "FS";
    Particles fsparticles = applyProjection<FinalState>(e, fskey).particles();
    // Remove prompt invisibles if needed (already done by VFS if using NO_INVISIBLES)
    if (_useInvisibles == JetAlg::DECAY_INVISIBLES)
      fsparticles.erase( std::remove_if(fsparticles.begin(), fsparticles.end(), isPromptInvisible), fsparticles.end() );
    // Remove prompt/all muons if needed
    if (_useMuons == JetAlg::DECAY_MUONS)
      fsparticles.erase( std::remove_if(fsparticles.begin(), fsparticles.end(), isPromptMuon), fsparticles.end() );
    else if (_useMuons == JetAlg::NO_MUONS)
      fsparticles.erase( std::remove_if(fsparticles.begin(), fsparticles.end(), isMuon), fsparticles.end() );

    // Tagging particles
    /// @todo Allow the user to specify tag particle kinematic thresholds
    const Particles chadrons = applyProjection<HeavyHadrons>(e, "HFHadrons").cHadrons();
    const Particles bhadrons = applyProjection<HeavyHadrons>(e, "HFHadrons").bHadrons();
    const Particles taus = applyProjection<FinalState>(e, "Taus").particles();
    calc(fsparticles, chadrons+bhadrons+taus);
  }
PseudoJets pseudoJets ( double  ptmin = 0.0) const

Get the pseudo jets (unordered).

Definition at line 200 of file FastJets.cc.

References FastJets::clusterSeq().

Referenced by FastJets::pseudojets(), FastJets::pseudoJetsByE(), FastJets::pseudoJetsByPt(), and FastJets::pseudoJetsByRapidity().

                                                    {
    return clusterSeq() ? clusterSeq()->inclusive_jets(ptmin) : PseudoJets();
  }
PseudoJets pseudojets ( double  ptmin = 0.0) const [inline]

Alias.

Definition at line 175 of file FastJets.hh.

References FastJets::pseudoJets().

Referenced by FastJets::_jets().

{ return pseudoJets(ptmin); }
PseudoJets pseudoJetsByE ( double  ptmin = 0.0) const [inline]

Get the pseudo jets, ordered by $ E $.

Definition at line 185 of file FastJets.hh.

References FastJets::pseudoJets().

Referenced by FastJets::pseudojetsByE().

                                                     {
      return sorted_by_E(pseudoJets(ptmin));
    }
PseudoJets pseudojetsByE ( double  ptmin = 0.0) const [inline]

Alias.

Definition at line 189 of file FastJets.hh.

References FastJets::pseudoJetsByE().

{ return pseudoJetsByE(ptmin); }
PseudoJets pseudoJetsByPt ( double  ptmin = 0.0) const [inline]

Get the pseudo jets, ordered by $ p_T $.

Definition at line 178 of file FastJets.hh.

References FastJets::pseudoJets().

Referenced by CDF_2008_S8095620::analyze(), CDF_2006_S6653332::analyze(), ATLAS_2012_I1094564::analyze(), and FastJets::pseudojetsByPt().

                                                      {
      return sorted_by_pt(pseudoJets(ptmin));
    }
PseudoJets pseudojetsByPt ( double  ptmin = 0.0) const [inline]

Alias.

Definition at line 182 of file FastJets.hh.

References FastJets::pseudoJetsByPt().

{ return pseudoJetsByPt(ptmin); }
PseudoJets pseudoJetsByRapidity ( double  ptmin = 0.0) const [inline]

Get the pseudo jets, ordered by rapidity.

Definition at line 192 of file FastJets.hh.

References FastJets::pseudoJets().

Referenced by FastJets::pseudojetsByRapidity().

                                                            {
      return sorted_by_rapidity(pseudoJets(ptmin));
    }
PseudoJets pseudojetsByRapidity ( double  ptmin = 0.0) const [inline]

Alias.

Definition at line 196 of file FastJets.hh.

References FastJets::pseudoJetsByRapidity().

{ return pseudoJetsByRapidity(ptmin); }
void reset ( ) [virtual]

Reset the projection. Jet def, etc. are unchanged.

Todo:
_cseq = fastjet::ClusterSequence();

Implements JetAlg.

Definition at line 176 of file FastJets.cc.

References FastJets::_particles, and FastJets::_yscales.

                       {
    _yscales.clear();
    _particles.clear();
    /// @todo _cseq = fastjet::ClusterSequence();
  }
void setName ( const std::string &  name) [inline, inherited]

Used by derived classes to set their name.

Definition at line 121 of file Projection.hh.

References Projection::_name, and Projection::name().

Referenced by FastJets::_initBase(), Beam::Beam(), BeamThrust::BeamThrust(), CentralEtHCM::CentralEtHCM(), ChargedFinalState::ChargedFinalState(), ChargedLeptons::ChargedLeptons(), ConstLossyFinalState::ConstLossyFinalState(), DISFinalState::DISFinalState(), DISKinematics::DISKinematics(), DISLepton::DISLepton(), DressedLeptons::DressedLeptons(), FinalState::FinalState(), FoxWolframMoments::FoxWolframMoments(), FParameter::FParameter(), HadronicFinalState::HadronicFinalState(), HeavyHadrons::HeavyHadrons(), Hemispheres::Hemispheres(), IdentifiedFinalState::IdentifiedFinalState(), InitialQuarks::InitialQuarks(), JetAlg::JetAlg(), JetShape::JetShape(), LeadingParticlesFinalState::LeadingParticlesFinalState(), LossyFinalState< ConstRandomFilter >::LossyFinalState(), MergedFinalState::MergedFinalState(), MissingMomentum::MissingMomentum(), NeutralFinalState::NeutralFinalState(), NonHadronicFinalState::NonHadronicFinalState(), NonPromptFinalState::NonPromptFinalState(), ParisiTensor::ParisiTensor(), PrimaryHadrons::PrimaryHadrons(), PromptFinalState::PromptFinalState(), SmearedJets::SmearedJets(), SmearedMET::SmearedMET(), SmearedParticles::SmearedParticles(), Sphericity::Sphericity(), Spherocity::Spherocity(), TauFinder::TauFinder(), Thrust::Thrust(), TriggerCDFRun0Run1::TriggerCDFRun0Run1(), TriggerCDFRun2::TriggerCDFRun2(), TriggerUA5::TriggerUA5(), UnstableFinalState::UnstableFinalState(), VetoedFinalState::VetoedFinalState(), VisibleFinalState::VisibleFinalState(), WFinder::WFinder(), and ZFinder::ZFinder().

                                        {
      _name = name;
    }
size_t size ( ) const [inline, inherited]

Number of jets (without cuts).

Definition at line 210 of file JetAlg.hh.

References JetAlg::jets().

Referenced by FastJets::_jets(), CDF_2008_S8095620::analyze(), CDF_2006_S6653332::analyze(), D0_2004_S5992206::analyze(), and JetAlg::empty().

{ return jets().size(); }
Jet trimJet ( const Jet input,
const fastjet::Filter &  trimmer 
) const

Trim (filter) a jet, keeping tag and constituent info in the resulting jet.

Definition at line 193 of file FastJets.cc.

References FastJets::_mkJet(), FastJets::clusterSeq(), and Jet::pseudojet().

                                                                          {
    assert(input.pseudojet().associated_cluster_sequence() == clusterSeq().get());
    PseudoJet pj = trimmer(input);
    return _mkJet(pj);
  }
void useInvisibles ( InvisiblesStrategy  useinvis = DECAY_INVISIBLES) [inline, inherited]

Include (some) invisible particles in jet construction.

The default behaviour is that jets are only constructed from visible particles. Some jet studies, including those from ATLAS, use a definition in which neutrinos from hadron decays are included via MC-based calibrations. Setting this flag to true avoids the automatic restriction to a VisibleFinalState.

Definition at line 61 of file JetAlg.hh.

References JetAlg::_useInvisibles.

Referenced by ATLAS_2015_I1387176::init(), CMS_2011_S8973270::init(), D0_2011_I895662::init(), ATLAS_2011_I930220::init(), ATLAS_2015_I1390114::init(), ATLAS_2015_I1404878::init(), ATLAS_2015_I1397635::init(), ATLAS_2011_S9128077::init(), D0_1995_I398175::init(), ATLAS_2014_I1319490::init(), ATLAS_2015_I1397637::init(), CDF_2008_S7782535::init(), ATLAS_2013_I1244522::init(), D0_2000_I499943::init(), ATLAS_2014_I1325553::init(), ATLAS_2016_I1444991::init(), ATLAS_2015_I1376945::init(), ATLAS_2015_I1345452::init(), ATLAS_2013_I1219109::init(), ATLAS_2014_I1268975::init(), CDF_2005_S6217184::init(), ATLAS_2011_S8924791::init(), ATLAS_2011_I945498::init(), ATLAS_2012_I1093738::init(), ATLAS_2013_I1217863_W::init(), JADE_OPAL_2000_S4300807::init(), ALEPH_2004_S5765862::init(), ATLAS_2013_I1217863_Z::init(), CMS_2014_I1303894::init(), MC_HFJETS::init(), ATLAS_2014_I1307243::init(), ATLAS_2013_I1230812::init(), ATLAS_2015_CONF_2015_041::init(), ATLAS_2012_I1082936::init(), ATLAS_2014_I1326641::init(), ATLAS_2014_I1304688::init(), ATLAS_2014_I1306294::init(), ATLAS_2012_I1083318::init(), ATLAS_2013_I1217867::init(), and ATLAS_2014_I1312627::init().

                                                                     {
      _useInvisibles = useinvis;
    }
void useInvisibles ( bool  useinvis) [inline, inherited]

Include (some) invisible particles in jet construction.

The default behaviour is that jets are only constructed from visible particles. Some jet studies, including those from ATLAS, use a definition in which neutrinos from hadron decays are included via MC-based calibrations. Setting this flag to true avoids the automatic restriction to a VisibleFinalState.

Deprecated:
Use the enum-arg version instead. Will be removed in Rivet v3

Definition at line 73 of file JetAlg.hh.

References JetAlg::_useInvisibles, JetAlg::DECAY_INVISIBLES, and JetAlg::NO_INVISIBLES.

void useJetArea ( fastjet::AreaDefinition *  adef) [inline]

Use provided jet area definition.

Warning:
The provided pointer must be heap-allocated: it will be stored/deleted via a shared_ptr.
Note:
Provide an adef null pointer to re-disable jet area calculation

Definition at line 161 of file FastJets.hh.

References FastJets::_adef.

Referenced by ATLAS_2016_I1457605::init(), ATLAS_2010_S8914702::init(), ATLAS_2011_I921594::init(), ATLAS_2014_I1307756::init(), ATLAS_2013_I1244522::init(), ATLAS_2011_S9120807::init(), ATLAS_2012_I1199269::init(), and ATLAS_2012_I1093738::init().

                                                 {
      _adef.reset(adef);
    }
void useMuons ( MuonsStrategy  usemuons = ALL_MUONS) [inline, inherited]

Include (some) muons in jet construction.

The default behaviour is that jets are only constructed from visible particles. Some jet studies, including those from ATLAS, use a definition in which neutrinos from hadron decays are included via MC-based calibrations. Setting this flag to true avoids the automatic restriction to a VisibleFinalState.

Definition at line 51 of file JetAlg.hh.

References JetAlg::_useMuons.

Referenced by ATLAS_2015_I1397637::init(), and ATLAS_2016_I1444991::init().

                                                    {
      _useMuons = usemuons;
    }

Friends And Related Function Documentation

friend class Cmp< Projection > [friend, inherited]

The Cmp specialization for Projection is a friend.

Definition at line 36 of file Projection.hh.

friend class Event [friend, inherited]

Event is a friend.

Definition at line 33 of file Projection.hh.


Member Data Documentation

std::shared_ptr<fastjet::AreaDefinition> _adef [private]

Pointer to user-handled area definition.

Definition at line 277 of file FastJets.hh.

Referenced by FastJets::areaDef(), FastJets::calc(), FastJets::compare(), and FastJets::useJetArea().

bool _allowProjReg [protected, inherited]

Flag to forbid projection registration in analyses until the init phase.

Definition at line 176 of file ProjectionApplier.hh.

Referenced by ProjectionApplier::_declareProjection(), and Analysis::Analysis().

std::shared_ptr<fastjet::ClusterSequence> _cseq [private]

Cluster sequence.

Definition at line 280 of file FastJets.hh.

Referenced by FastJets::calc(), FastJets::clusterSeq(), and FastJets::clusterSeqArea().

fastjet::JetDefinition _jdef [private]

Jet definition.

Definition at line 274 of file FastJets.hh.

Referenced by FastJets::_initJdef(), FastJets::calc(), FastJets::compare(), and FastJets::jetDef().

std::map<int, Particle> _particles [private]

set of particles sorted by their PT2

Definition at line 290 of file FastJets.hh.

Referenced by FastJets::_mkJet(), FastJets::calc(), and FastJets::reset().

std::shared_ptr<fastjet::JetDefinition::Plugin> _plugin [private]

FastJet external plugin.

Definition at line 283 of file FastJets.hh.

Referenced by FastJets::_initJdef(), and FastJets::FastJets().

InvisiblesStrategy _useInvisibles [protected, inherited]

Flag to determine whether or not to exclude (some) invisible particles from the would-be constituents.

Definition at line 242 of file JetAlg.hh.

Referenced by FastJets::compare(), FastJets::project(), and JetAlg::useInvisibles().

MuonsStrategy _useMuons [protected, inherited]

Flag to determine whether or not to exclude (some) muons from the would-be constituents.

Definition at line 239 of file JetAlg.hh.

Referenced by FastJets::compare(), FastJets::project(), and JetAlg::useMuons().

std::map<int, vector<double> > _yscales [mutable, private]

Map of vectors of y scales. This is mutable so we can use caching/lazy evaluation.

Definition at line 286 of file FastJets.hh.

Referenced by FastJets::reset().


The documentation for this class was generated from the following files: