DISLepton.hh

// -*- C++ -*-
#ifndef RIVET_DISLepton_HH
#define RIVET_DISLepton_HH
 
#include "Rivet/Event.hh"
#include "Rivet/Particle.hh"
#include "Rivet/Projections/Beam.hh"
#include "Rivet/Projections/HadronicFinalState.hh"
#include "Rivet/Projections/LeptonFinder.hh"
#include "Rivet/Projections/PromptFinalState.hh"
#include "Rivet/Projections/UndressBeamLeptons.hh"
#include "Rivet/Projections/VetoedFinalState.hh"
 
namespace Rivet {

  enum class DISMode { L2L, L2NU, NU2L, NU2NU };

  class DISLepton : public FinalState {
  public:


    DISLepton(const Cut& cuts = Cuts::OPEN,
              LeptonReco lreco = LeptonReco::ALL,
              ObjOrdering lsort = ObjOrdering::ENERGY,
              double beamundresstheta = 0.0,
              double isolDR = 0.0,
              double dressDR = 0.0,
              DISMode dismode = DISMode::L2L)
        : _isolDR(isolDR), _lsort(lsort), _lreco(lreco), _dismode(dismode) {
      setName("DISLepton");
      declare(HadronicFinalState(), "IFS");
 
      // Beam undressing
      if (beamundresstheta > 0.0) {
        declare(UndressBeamLeptons(beamundresstheta), "Beam");
      }
      else {
        declare(Beam(), "Beam");
      }
 
      // Lepton reco mode
      switch (_lreco) {
        case LeptonReco::ALL: declare(FinalState(cuts), "LFS"); break;
        case LeptonReco::ALL_DRESSED: declare(LeptonFinder(FinalState(), dressDR, cuts), "LFS"); break;
        case LeptonReco::PROMPT_BARE: declare(PromptFinalState(cuts), "LFS"); break;
        case LeptonReco::PROMPT_DRESSED:
          declare(LeptonFinder(PromptFinalState(), dressDR, cuts), "LFS");
          break;
      }
 
      // Identify the non-outgoing-lepton part of the event
      VetoedFinalState remainingFS;
      remainingFS.addVetoOnThisFinalState(*this);
      declare(remainingFS, "RFS");
    }
 

    DISLepton(Cut& cuts,
              LeptonReco lreco = LeptonReco::ALL,
              double beamundresstheta = 0.0,
              double isolDR = 0.0,
              double dressDR = 0.0,
              DISMode dismode = DISMode::L2L)
        : DISLepton(cuts, lreco, ObjOrdering::ENERGY, beamundresstheta, isolDR, dressDR, dismode) { }

    DISLepton(LeptonReco lreco,
              ObjOrdering lsort = ObjOrdering::ENERGY,
              double beamundresstheta = 0.0,
              double isolDR = 0.0,
              double dressDR = 0.0,
              DISMode dismode = DISMode::L2L)
        : DISLepton(Cuts::OPEN, lreco, lsort, beamundresstheta, isolDR, dressDR, dismode) { }

    DISLepton(LeptonReco lreco,
              double beamundresstheta = 0.0,
              double isolDR = 0.0,
              double dressDR = 0.0,
              DISMode dismode = DISMode::L2L)
        : DISLepton(Cuts::OPEN, lreco, ObjOrdering::ENERGY, beamundresstheta, isolDR, dressDR, dismode) { }
 

    RIVET_DEFAULT_PROJ_CLONE(DISLepton);


    using Projection::operator=;
 
 
  protected:

    virtual void project(const Event& e);

    virtual CmpState compare(const Projection& p) const;
 
 
  public:

    const Particle& in() const {
      return _incoming;
    }

    const Particle& out() const {
      return _outgoing;
    }

    int pzSign() const {
      return sign(_incoming.pz());
    }

    LeptonReco reconstructionMode() const {
      return _lreco;
    }
 

    const VetoedFinalState& remainingFinalState() const;

    void clear() {
      _theParticles.clear();
    }
 
 
  protected:

    Particle _incoming;

    Particle _outgoing;

    double _isolDR;

    ObjOrdering _lsort;

    LeptonReco _lreco;

    DISMode _dismode;
  };
 
 
}
 
#endif