rivet is hosted by Hepforge, IPPP Durham
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Friends
JetAlg Class Reference

Abstract base class for projections which can return a set of Jets. More...

#include <JetAlg.hh>

List of all members.

Public Types

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

 JetAlg (const FinalState &fs, MuonsStrategy usemuons=JetAlg::ALL_MUONS, InvisiblesStrategy useinvis=JetAlg::NO_INVISIBLES)
 Constructor.
 JetAlg ()
 Default constructor.
virtual unique_ptr< Projection > clone () const =0
 Clone on the heap.
virtual ~JetAlg ()
 Destructor.
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.
virtual void reset ()=0
 Clear the projection.
collection_type entities () const
 Template-usable interface common to FinalState.
bool before (const Projection &p) const
virtual const std::set< PdgIdPair > beamPairs () const
virtual std::string name () const
 Get the name of the projection.
Projection & addPdgIdPair (PdgId beam1, PdgId beam2)
 Add a colliding beam pair.
Log & getLog () 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
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 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
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
Projection "getting" functions
std::set< ConstProjectionPtr > getProjections () const
 Get the contained projections, including recursion.
template<typename PROJ >
const PROJ & getProjection (const std::string &name) const
const Projection & getProjection (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

virtual Jets _jets () const =0
 Internal pure virtual method for getting jets in no guaranteed order.
virtual void project (const Event &e)=0
 Perform the projection on the Event.
virtual int compare (const Projection &p) const =0
 Compare projections.
Cmp< Projection > mkNamedPCmp (const Projection &otherparent, const std::string &pname) const
Cmp< Projection > mkPCmp (const Projection &otherparent, const std::string &pname) const
ProjectionHandler & getProjHandler () 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.

Friends

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

Detailed Description

Abstract base class for projections which can return a set of Jets.

Definition at line 15 of file JetAlg.hh.

Member Typedef Documentation

typedef Jets collection_type

Definition at line 218 of file JetAlg.hh.

typedef Jet entity_type

Definition at line 217 of file JetAlg.hh.

Member Enumeration Documentation

enum InvisiblesStrategy

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.

{ NO_INVISIBLES, DECAY_INVISIBLES, ALL_INVISIBLES };
enum MuonsStrategy

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.

{ NO_MUONS, DECAY_MUONS, ALL_MUONS };

Constructor & Destructor Documentation

JetAlg ( const FinalState &  fs,
MuonsStrategy  usemuons = JetAlg::ALL_MUONS,
InvisiblesStrategy  useinvis = JetAlg::NO_INVISIBLES 
)

Constructor.

Definition at line 7 of file JetAlg.cc.

    : _useMuons(usemuons), _useInvisibles(useinvis)
  {
    setName("JetAlg");
    addProjection(fs, "FS");
    VisibleFinalState vfs(fs);
    MSG_DEBUG("Making visible final state from provided FS");
    addProjection(vfs, "VFS");
  }
JetAlg ( ) [inline]

Default constructor.

Definition at line 30 of file JetAlg.hh.

{};
virtual ~JetAlg ( ) [inline, virtual]

Destructor.

Definition at line 36 of file JetAlg.hh.

{ }

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.

                                                                                  {
    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.

                                                                                      {
    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.

                                                                             {
    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;
  }
virtual Jets _jets ( ) const [protected, pure virtual]

Internal pure virtual method for getting jets in no guaranteed order.

Implemented in FastJets, and SmearedJets.

Projection& addPdgIdPair ( PdgId  beam1,
PdgId  beam2 
) [inline, inherited]

Add a colliding beam pair.

Definition at line 108 of file Projection.hh.

                                                       {
      _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.

{ 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.

{ 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.

                                                                                {
      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.

                                                                          {
      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.

                                                                               {
      return pcast<PROJ>(_applyProjection(evt, name));
    }
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.

                                                   {
    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.

                                                   {
    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);
    }
  }
virtual unique_ptr<Projection> clone ( ) const [pure virtual]

Clone on the heap.

Implements Projection.

virtual int compare ( const Projection &  p) const [protected, pure virtual]

Compare projections.

Implements Projection.

Implemented in FastJets, and SmearedJets.

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.

{ 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.

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

Whether the inclusive jet collection is empty.

Definition at line 212 of file JetAlg.hh.

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

Template-usable interface common to FinalState.

Definition at line 221 of file JetAlg.hh.

{ 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.

{ 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.

                        {
      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.

                                                           {
      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.

                                                                 {
      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.

                                                      {
      return getProjHandler().getChildProjections(*this, ProjectionHandler::DEEP);
    }
ProjectionHandler& getProjHandler ( ) const [inline, protected, inherited]

Get a reference to the ProjectionHandler for this thread.

Definition at line 122 of file ProjectionApplier.hh.

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

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.

                                                     {
      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 ( F  sorter,
const Cut &  c = Cuts::open() 
) const [inline]
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.

                                                       {
      /// @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,
F  sorter 
) const [inline]

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.

                                            {
      /// @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]

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.

                                                        {
      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]

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.

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

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.

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

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.

                                                {
      return jets(c, cmpMomByP);
    }
Jets jetsByPt ( const Cut &  c = Cuts::open()) const [inline]

Get the jets, ordered by $ p_T $, with optional cuts.

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(c, cmpMomByPt).

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

Definition at line 126 of file JetAlg.hh.

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

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.

                                      {
      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.

{ _owned = true; }
Cmp< Projection > mkNamedPCmp ( 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.

Definition at line 47 of file Projection.cc.

                                                                                                  {
    return pcmp(*this, otherparent, pname);
  }
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.

                                                                                             {
    return pcmp(*this, otherparent, pname);
  }
virtual std::string name ( ) const [inline, virtual, inherited]

Get the name of the projection.

Implements ProjectionApplier.

Definition at line 102 of file Projection.hh.

                                   {
      return _name;
    }
size_t numJets ( const Cut &  c = Cuts::open()) const [inline]

Number of jets passing the provided Cut.

Definition at line 207 of file JetAlg.hh.

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

Perform the projection on the Event.

Implements Projection.

Implemented in FastJets, and SmearedJets.

virtual void reset ( ) [pure virtual]

Clear the projection.

Implemented in FastJets, and SmearedJets.

void setName ( const std::string &  name) [inline, inherited]

Used by derived classes to set their name.

Definition at line 121 of file Projection.hh.

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

Number of jets (without cuts).

Definition at line 210 of file JetAlg.hh.

{ return jets().size(); }
void useInvisibles ( InvisiblesStrategy  useinvis = DECAY_INVISIBLES) [inline]

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.

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

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.

                                      {
      _useInvisibles = useinvis ? DECAY_INVISIBLES : NO_INVISIBLES;
    }
void useMuons ( MuonsStrategy  usemuons = ALL_MUONS) [inline]

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.

                                                    {
      _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

bool _allowProjReg [protected, inherited]

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

Definition at line 176 of file ProjectionApplier.hh.

InvisiblesStrategy _useInvisibles [protected]

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

Definition at line 242 of file JetAlg.hh.

MuonsStrategy _useMuons [protected]

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

Definition at line 239 of file JetAlg.hh.

The documentation for this class was generated from the following files:
Generated on Tue Dec 13 2016 16:32:48 for The Rivet MC analysis system by   doxygen 1.7.6.1