ParticleSmearingFunctions.hh

// -*- C++ -*-
#ifndef RIVET_ParticleSmearingFunctions_HH
#define RIVET_ParticleSmearingFunctions_HH
 
#include "Rivet/Particle.hh"
#include "Rivet/Tools/MomentumSmearingFunctions.hh"
#include "Rivet/Tools/Random.hh"
 
namespace Rivet {
 



  typedef function<Particle(const Particle&)> ParticleSmearFn;

  typedef function<double(const Particle&)> ParticleEffFn;
 

  inline double PARTICLE_EFF_ZERO(const Particle&) {
    return 0;
  }

  inline double PARTICLE_EFF_0(const Particle&) {
    return 0;
  }

  inline double PARTICLE_FN0(const Particle&) {
    return 0;
  }

  inline double PARTICLE_EFF_ONE(const Particle&) {
    return 1;
  }

  inline double PARTICLE_EFF_1(const Particle&) {
    return 1;
  }

  inline double PARTICLE_EFF_PERFECT(const Particle&) {
    return 1;
  }

  inline double PARTICLE_FN1(const Particle&) {
    return 1;
  }

  struct PARTICLE_EFF_CONST {
    PARTICLE_EFF_CONST(double x)
        : _x(x) { }
    double operator()(const Particle&) const {
      return _x;
    }
    double _x;
  };
 

  inline Particle PARTICLE_SMEAR_IDENTITY(const Particle& p) {
    return p;
  }

  inline Particle PARTICLE_SMEAR_PERFECT(const Particle& p) {
    return p;
  }
 

  struct ParticleEffSmearFn {
    ParticleEffSmearFn(const ParticleSmearFn& s, const ParticleEffFn& e)
        : sfn(s), efn(e) { }
 
    ParticleEffSmearFn(const ParticleEffFn& e, const ParticleSmearFn& s)
        : sfn(s), efn(e) { }
 
    ParticleEffSmearFn(const ParticleSmearFn& s)
        : sfn(s), efn(PARTICLE_EFF_ONE) { }
 
    ParticleEffSmearFn(const ParticleEffFn& e)
        : sfn(PARTICLE_SMEAR_IDENTITY), efn(e) { }
 
    ParticleEffSmearFn(double eff)
        : ParticleEffSmearFn(PARTICLE_EFF_CONST(eff)) { }

    pair<Particle, double> operator()(const Particle& p) const {
      return make_pair(sfn(p), efn(p));
    }

    CmpState cmp(const ParticleEffSmearFn& other) const {
      // cout << "Eff hashes = " << get_address(efn) << "," << get_address(other.efn) << "; "
      //      << "smear hashes = " << get_address(sfn) << "," << get_address(other.sfn) << '\n';
      if (get_address(sfn) == 0 || get_address(other.sfn) == 0) return CmpState::NEQ;
      if (get_address(efn) == 0 || get_address(other.efn) == 0) return CmpState::NEQ;
      return Rivet::cmp(get_address(sfn), get_address(other.sfn))
          || Rivet::cmp(get_address(efn), get_address(other.efn));
    }

    operator ParticleSmearFn() {
      return sfn;
    }

    operator ParticleEffFn() {
      return efn;
    }
 
    // Stored functions/functors
    const ParticleSmearFn sfn;
    const ParticleEffFn efn;
  };
 

  inline bool efffilt(const Particle& p, const ParticleEffFn& feff) {
    return rand01() < feff(p);
  }

  struct ParticleEffFilter {
    template <typename FN>
    ParticleEffFilter(const FN& feff)
        : _feff(feff) { }
    ParticleEffFilter(double eff)
        : ParticleEffFilter([&](const Particle&) { return eff; }) { }
    bool operator()(const Particle& p) const {
      return efffilt(p, _feff);
    }
 
  private:
 
    const ParticleEffFn _feff;
  };
  using particleEffFilter = ParticleEffFilter;


 
}
 
#endif