Get the highest-pT occurrences of FS particles with the specified PDG IDs. More...

#include <LeadingParticlesFinalState.hh>

Public Member Functions
	LeadingParticlesFinalState (const FinalState &fsp)
	Constructor: the supplied FinalState projection is assumed to live through the run.
	DEFAULT_RIVET_PROJ_CLONE (LeadingParticlesFinalState)
	Clone on the heap.
LeadingParticlesFinalState &	addParticleId (long id)
	Add a particle ID to the list of leading particles selected.
LeadingParticlesFinalState &	addParticleIdPair (long id)
	Add a particle ID to the list of leading particles selected.
void	setLeadingOnly (const bool &leadingonly)
virtual bool	accept (const Particle &p) const
	Decide if a particle is to be accepted or not.
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
Standard constructors etc.
	DEFAULT_RIVET_PROJ_CLONE (FinalState)
	Clone on the heap.
Object lifetime management
virtual unique_ptr< Projection >	clone () const =0
	Clone on the heap.
Particle accessors
virtual const Particles &	particles () const
	Get the final-state particles in no particular order, with no cuts.
Particles	particles (const Cut &c) const
	Get the final-state particles, with optional cuts.
template<typename F >
Particles	particles (F sorter, const Cut &c=Cuts::open()) const
template<typename F >
Particles	particles (const Cut &c, F sorter) const
size_t	size () const
	Access the projected final-state particles.
bool	empty () const
	Is this final state empty?
bool	isEmpty () const
Particles	particlesByPt (const Cut &c=Cuts::open()) const
Particles	particlesByPt (double ptmin) const
Little-used sorted accessors
Deprecated: Use the versions with a sorter function argument
Particles	particlesByP (const Cut &c=Cuts::open()) const
Particles	particlesByE (const Cut &c=Cuts::open()) const
Particles	particlesByEt (const Cut &c=Cuts::open()) const
Particles	particlesByEta (const Cut &c=Cuts::open()) const
Particles	particlesByModEta (const Cut &c=Cuts::open()) const
Particles	particlesByRapidity (const Cut &c=Cuts::open()) const
Particles	particlesByModRapidity (const Cut &c=Cuts::open()) 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
void	project (const Event &e)
	Apply the projection on the supplied event.
int	compare (const Projection &p) const
	Compare projections.
bool	inList (const Particle &particle) const
	Check if the particle's ID is in the list.
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
Cut	_cuts
	The kinematic cuts cuts.
Particles	_theParticles
	The found particles returned by the particles() methods.
bool	_allowProjReg
	Flag to forbid projection registration in analyses until the init phase.
Private Attributes
std::set< long >	_ids
	IDs of the leading particles to be selected.
bool	_leading_only
Friends
class	Event
	Event is a friend.
class	Cmp< Projection >
	The Cmp specialization for Projection is a friend.
For JetAlg compatibility
Todo: Replace with cuts() accessor virtual Cut cuts() const { return _cuts; }
const collection_type &	entities () const
	Template-usable interface common to JetAlg.
typedef Particle	entity_type
typedef Particles	collection_type

Detailed Description

Get the highest-pT occurrences of FS particles with the specified PDG IDs.

Definition at line 13 of file LeadingParticlesFinalState.hh.

Member Typedef Documentation

typedef Particles collection_type [inherited]

Definition at line 173 of file ParticleFinder.hh.

typedef Particle entity_type [inherited]

Definition at line 172 of file ParticleFinder.hh.

Constructor & Destructor Documentation

LeadingParticlesFinalState ( const FinalState & fsp ) [inline]

Constructor: the supplied FinalState projection is assumed to live through the run.

Definition at line 18 of file LeadingParticlesFinalState.hh.

      :  FinalState(), _leading_only(false)
    {
      setName("LeadingParticlesFinalState");
      addProjection(fsp, "FS");
    }

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;
  }

bool accept ( const Particle & p ) const [virtual, inherited]

Decide if a particle is to be accepted or not.

Todo:: Rename to _accept or acceptFinal?

Reimplemented in FinalPartons.

Definition at line 75 of file FinalState.cc.

                                                 {
    // Not having status == 1 should never happen!
    assert(p.genParticle() == NULL || p.genParticle()->status() == 1);
    return _cuts->accept(p);
  }

LeadingParticlesFinalState& addParticleId ( long id ) [inline]

Add a particle ID to the list of leading particles selected.

Definition at line 29 of file LeadingParticlesFinalState.hh.

                                                       {
      _ids.insert(id);
      return *this;
    }

LeadingParticlesFinalState& addParticleIdPair ( long id ) [inline]

Add a particle ID to the list of leading particles selected.

Definition at line 35 of file LeadingParticlesFinalState.hh.

                                                           {
      _ids.insert(id);
      _ids.insert(-id);
      return *this;
    }

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, inherited]

Clone on the heap.

Implements Projection.

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

Compare projections.

Reimplemented from FinalState.

Definition at line 7 of file LeadingParticlesFinalState.cc.

                                                                   {
    // First compare the final states we are running on
    int fscmp = mkNamedPCmp(p, "FS");
    if (fscmp != EQUIVALENT) return fscmp;

    // Then compare the two as final states
    const LeadingParticlesFinalState& other = dynamic_cast<const LeadingParticlesFinalState&>(p);
    fscmp = FinalState::compare(other);
    if (fscmp != EQUIVALENT) return fscmp;

    int locmp = cmp(_leading_only, other._leading_only);
    if (locmp != EQUIVALENT) return locmp;

    // Finally compare the IDs
    if (_ids < other._ids) return ORDERED;
    else if (other._ids < _ids) return UNORDERED;
    return EQUIVALENT;
  }

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;
    }

DEFAULT_RIVET_PROJ_CLONE ( LeadingParticlesFinalState )

Clone on the heap.

DEFAULT_RIVET_PROJ_CLONE ( FinalState ) [inherited]

Clone on the heap.

bool empty ( ) const [inline, inherited]

Is this final state empty?

Definition at line 41 of file ParticleFinder.hh.

{ return particles().empty(); }

const collection_type& entities ( ) const [inline, inherited]

Template-usable interface common to JetAlg.

Definition at line 176 of file ParticleFinder.hh.

                                            {
      return particles();
    }

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;
    }

bool inList ( const Particle & particle ) const [protected]

Check if the particle's ID is in the list.

Definition at line 78 of file LeadingParticlesFinalState.cc.

                                                                         {
    std::set < long >::const_iterator ilist = _ids.find(particle.pid());
    if (ilist != _ids.end()) return true;
    return false;
  }

bool isEmpty ( ) const [inline, inherited]

Deprecated:: Is this final state empty?

Definition at line 44 of file ParticleFinder.hh.

{ return particles().empty(); }

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;
    }

virtual const Particles& particles ( ) const [inline, virtual, inherited]

Get the final-state particles in no particular order, with no cuts.

Definition at line 35 of file ParticleFinder.hh.

{ return _theParticles; }

Particles particles ( const Cut & c ) const [inline, inherited]

Get the final-state particles, with optional cuts.

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

Todo:: Can't this be a const Cut& arg?

Definition at line 50 of file ParticleFinder.hh.

                                            {
      // Just return a copy of particles() if the cut is open
      if (c == Cuts::open()) return particles();
      // If there is a non-trivial cut...
      Particles rtn;
      rtn.reserve(size());
      foreach (const Particle& p, particles())
        if (c->accept(p)) rtn.push_back(p);
      return rtn;
    }

Particles particles	(	F	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?

Use a std::function instead of typename F?

Get the final-state particles, ordered by supplied sorting function object.

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

Todo:: Can't this be a const Cut& arg?

Todo:: Will the vector be efficiently std::move'd by value through this function chain?

Definition at line 70 of file ParticleFinder.hh.

                                                                 {
      /// @todo Will the vector be efficiently std::move'd by value through this function chain?
      return sortBy(particles(c), sorter);
    }

Particles particles	(	const Cut &	c,
		F	sorter
	)		const `[inline, inherited]`

Get the final-state particles, ordered by supplied sorting function object.

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

Todo:

Can't this be a const Cut& arg?

Use a std::function instead of typename F?

Todo:: Will the vector be efficiently std::move'd by value through this function chain?

Definition at line 80 of file ParticleFinder.hh.

                                                      {
      /// @todo Will the vector be efficiently std::move'd by value through this function chain?
      return sortBy(particles(c), sorter);
    }

Particles particlesByE ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by decreasing $ E $ .

Todo:: Remove, since there is the templated method or sortByX methods available for these unusual cases?

Deprecated:: Use the version with a sorter function argument

Definition at line 116 of file ParticleFinder.hh.

                                                           {
      return particles(c, cmpMomByE);
    }

Particles particlesByEt ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by decreasing $ E_T $ .

Todo:: Remove, since there is the templated method or sortByX methods available for these unusual cases?

Deprecated:: Use the version with a sorter function argument

Definition at line 124 of file ParticleFinder.hh.

                                                            {
      return particles(c, cmpMomByEt);
    }

Particles particlesByEta ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by increasing $\eta$ .

Todo:: Remove, since there is the templated method or sortByX methods available for these unusual cases?

Deprecated:: Use the version with a sorter function argument

Definition at line 132 of file ParticleFinder.hh.

                                                             {
      return particles(c, cmpMomByEta);
    }

Particles particlesByModEta ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by increasing $|\eta|$ .

Todo:: Remove, since there is the templated method or sortByX methods available for these unusual cases?

Deprecated:: Use the version with a sorter function argument

Definition at line 140 of file ParticleFinder.hh.

                                                                {
      return particles(c, cmpMomByAbsEta);
    }

Particles particlesByModRapidity ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by increasing $ |y| $ .

Todo:: Remove, since there is the templated method or sortByX methods available for these unusual cases?

Deprecated:: Use the version with a sorter function argument

Definition at line 156 of file ParticleFinder.hh.

                                                                     {
      return particles(c, cmpMomByAbsRap);
    }

Particles particlesByP ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by decreasing $ p $ .

Todo:: Remove, since there is the templated method or sortByX methods available for these unusual cases?

Deprecated:: Use the version with a sorter function argument

Definition at line 108 of file ParticleFinder.hh.

                                                           {
      return particles(c, cmpMomByP);
    }

Particles particlesByPt ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by decreasing $ p_T $ and with optional cuts.

This is a very common use-case, so is available as syntatic sugar for particles(c, cmpMomByPt).

Definition at line 88 of file ParticleFinder.hh.

                                                           {
      return particles(c, cmpMomByPt);
    }

Particles particlesByPt ( double ptmin ) const [inline, inherited]

Get the final-state particles, ordered by decreasing $ p_T $ and with a cut on minimum $ p_T $ .

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

Definition at line 95 of file ParticleFinder.hh.

                                                {
      return particles(Cuts::pT >= ptmin, cmpMomByPt);
    }

Particles particlesByRapidity ( const Cut & c = Cuts::open() ) const [inline, inherited]

Get the final-state particles, ordered by increasing $ y $ .

Todo:: Remove, since there is the templated method or sortByX methods available for these unusual cases?

Deprecated:: Use the version with a sorter function argument

Definition at line 148 of file ParticleFinder.hh.

                                                                  {
      return particles(c, cmpMomByRap);
    }

void project ( const Event & e ) [protected, virtual]

Apply the projection on the supplied event.

Reimplemented from FinalState.

Definition at line 27 of file LeadingParticlesFinalState.cc.

                                                          {
    _theParticles.clear();
    const FinalState& fs = applyProjection<FinalState>(e, "FS");

    // Temporary container
    map<long, Particles::const_iterator> tmp;

    const Particles& particles = fs.particles();
    MSG_DEBUG("Original final state particles size " << particles.size());
    Particles::const_iterator ifs;
    for (ifs = particles.begin(); ifs != particles.end(); ++ifs) {
      if (inList(*ifs) && FinalState::accept(*ifs->genParticle())) {
        // Look for an existing particle in tmp container
        map < long, Particles::const_iterator >::const_iterator itmp = tmp.find(ifs->pid());
        if (itmp != tmp.end()) {  // if a particle with this type has been already selected
          // If the new pT is higher than the previous one, then substitute...
          if (ifs->pT() > itmp->second->pT()) {
            tmp[ifs->pid()] = ifs;
          }
          // ...otherwise insert in the container
        } else {
          tmp[ifs->pid()] = ifs;
        }
      }
    }

    // Loop on the tmp container and fill _theParticles
    map<long, Particles::const_iterator>::const_iterator i;
    for (i = tmp.begin(); i != tmp.end(); ++i) {
      MSG_DEBUG("LeadingParticlesFinalState is accepting particle ID " << i->second->pid()
               << " with momentum " << i->second->momentum());
      _theParticles.push_back(*(i->second));
    }

    if (_leading_only) {
      double ptmax=0.0;
      Particle pmax;

      foreach (const Particle& p, _theParticles) {
        if (p.pT() > ptmax) {
          ptmax = p.pT();
          pmax = p;
        }
      }

      _theParticles.clear();
      _theParticles.push_back(pmax);
    }
  }

void setLeadingOnly ( const bool & leadingonly ) [inline]

Toggle whether to keep track only of the leading particle of any ID, or the leading particle of all IDs separately Default is the latter (=false)

Definition at line 44 of file LeadingParticlesFinalState.hh.

                                                 {
      _leading_only = leadingonly;
    }

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, inherited]

Access the projected final-state particles.

Definition at line 38 of file ParticleFinder.hh.

{ return particles().size(); }

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.

Cut _cuts [protected, inherited]

The kinematic cuts cuts.

Definition at line 192 of file ParticleFinder.hh.

std::set<long> _ids [private]

IDs of the leading particles to be selected.

Definition at line 69 of file LeadingParticlesFinalState.hh.

bool _leading_only [private]

Definition at line 70 of file LeadingParticlesFinalState.hh.

Particles _theParticles [protected, inherited]

The found particles returned by the particles() methods.

Definition at line 195 of file ParticleFinder.hh.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Friends

For JetAlg compatibility

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation