DressedLeptons.hh

// -*- C++ -*-
#ifndef RIVET_DressedLeptons_HH
#define RIVET_DressedLeptons_HH

#include "Rivet/Projection.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Projections/IdentifiedFinalState.hh"
#include "Rivet/Config/RivetCommon.hh"

namespace Rivet {


  class DressedLepton : public Particle {
  public:

    DressedLepton(const Particle& dlepton);

    DressedLepton(const Particle& lepton, const Particles& photons, bool momsum=true);

    void addPhoton(const Particle& p, bool momsum=true);

    const Particle& bareLepton() const;
    const Particle& constituentLepton() const { return bareLepton(); }

    const Particles photons() const { return slice(constituents(), 1); }
    const Particles constituentPhotons() const { return photons(); }

  };


  class DressedLeptons : public FinalState {
  public:

    DressedLeptons(const FinalState& barefs,
                   double dRmax, const Cut& cut=Cuts::open(),
                   bool useDecayPhotons=false,
                   bool useJetClustering=false);

    DressedLeptons(double dRmax, const Cut& cut=Cuts::open(),
                   bool useDecayPhotons=false,
                   bool useJetClustering=false)
      : DressedLeptons(FinalState(), dRmax, cut, useDecayPhotons, useJetClustering)
    {   }

    DressedLeptons(const FinalState& photons, const FinalState& bareleptons,
                   double dRmax, const Cut& cut=Cuts::open(),
                   bool useDecayPhotons=false,
                   bool useJetClustering=false);


    DEFAULT_RIVET_PROJ_CLONE(DressedLeptons);


    vector<DressedLepton> dressedLeptons() const {
      vector<DressedLepton> rtn;
      for (const Particle& p : particles(cmpMomByPt))
        rtn += DressedLepton(p);  //static_cast<const DressedLepton>(p);
      return rtn;
    }

    vector<DressedLepton> dressedLeptons(const ParticleSorter& sorter) const {
      vector<DressedLepton> rtn;
      for (const Particle& p : particles(sorter))
        rtn += DressedLepton(p);  //static_cast<const DressedLepton>(p);
      return rtn;
    }


  protected:

    void project(const Event& e);

    CmpState compare(const Projection& p) const;


  private:

    double _dRmax;

    bool _fromDecay;

    bool _useJetClustering;


  };



}


#endif