ParticleUtils.hh

#ifndef RIVET_PARTICLEUTILS_HH
#define RIVET_PARTICLEUTILS_HH
 
#include "Rivet/Particle.hh"
#include "Rivet/Tools/ParticleBaseUtils.hh"
#include "Rivet/Tools/ParticleIdUtils.hh"
 
// Macros to map Rivet::Particle functions to PID:: functions of the same name
#define PARTICLE_TO_PID_BOOLFN(fname) inline bool fname (const Particle& p) { return PID:: fname (p.pid()); }
#define PARTICLE_TO_PID_INTFN(fname) inline int fname (const Particle& p) { return PID:: fname (p.pid()); }
#define PARTICLE_TO_PID_DBLFN(fname) inline double fname (const Particle& p) { return PID:: fname (p.pid()); }
 
namespace Rivet {
 
 
 
 
  inline int pid(const Particle& p) { return p.pid(); }
 
  inline int abspid(const Particle& p) { return p.abspid(); }
 
 
  PARTICLE_TO_PID_BOOLFN(isCharged)
 
  
  PARTICLE_TO_PID_BOOLFN(isNeutral)
 
 
  
  PARTICLE_TO_PID_BOOLFN(isNeutrino)
 
  
  PARTICLE_TO_PID_BOOLFN(isChargedLepton)
 
  
  PARTICLE_TO_PID_BOOLFN(isLepton)
 
  
  PARTICLE_TO_PID_BOOLFN(isPhoton)
 
  
  PARTICLE_TO_PID_BOOLFN(isElectron)
 
  
  PARTICLE_TO_PID_BOOLFN(isMuon)
 
  
  PARTICLE_TO_PID_BOOLFN(isTau)
 
  
  PARTICLE_TO_PID_BOOLFN(isHadron)
 
  
  PARTICLE_TO_PID_BOOLFN(isMeson)
 
  
  PARTICLE_TO_PID_BOOLFN(isBaryon)
 
  
  PARTICLE_TO_PID_BOOLFN(isQuark)
 
  
  PARTICLE_TO_PID_BOOLFN(isParton)
 
 
 
  
  PARTICLE_TO_PID_BOOLFN(isWplus)
 
  
  PARTICLE_TO_PID_BOOLFN(isWminus)
 
  
  PARTICLE_TO_PID_BOOLFN(isW)
 
  
  PARTICLE_TO_PID_BOOLFN(isZ)
 
  
  PARTICLE_TO_PID_BOOLFN(isHiggs)
 
  
  PARTICLE_TO_PID_BOOLFN(isStrange)
 
  
  PARTICLE_TO_PID_BOOLFN(isCharm)
 
  
  PARTICLE_TO_PID_BOOLFN(isBottom)
 
  
  PARTICLE_TO_PID_BOOLFN(isTop)
 
 
  
  PARTICLE_TO_PID_BOOLFN(isHeavyFlavour)
 
  
  PARTICLE_TO_PID_BOOLFN(isHeavyParton)
 
  
  PARTICLE_TO_PID_BOOLFN(isLightParton)
 
 
  
  PARTICLE_TO_PID_BOOLFN(isHeavyMeson)
 
  
  PARTICLE_TO_PID_BOOLFN(isHeavyBaryon)
 
  
  PARTICLE_TO_PID_BOOLFN(isHeavyHadron)
 
 
  
  PARTICLE_TO_PID_BOOLFN(isLightMeson)
 
  
  PARTICLE_TO_PID_BOOLFN(isLightBaryon)
 
  
  PARTICLE_TO_PID_BOOLFN(isLightHadron)
 
 
  
  PARTICLE_TO_PID_BOOLFN(isBottomMeson)
 
  
  PARTICLE_TO_PID_BOOLFN(isBottomBaryon)
 
  
  PARTICLE_TO_PID_BOOLFN(isBottomHadron)
 
 
  
  PARTICLE_TO_PID_BOOLFN(isCharmMeson)
 
  
  PARTICLE_TO_PID_BOOLFN(isCharmBaryon)
 
  
  PARTICLE_TO_PID_BOOLFN(isCharmHadron)
 
 
  // /// Determine if the PID is that of a strange meson
  // PARTICLE_TO_PID_BOOLFN(isStrangeMeson)
 
  // /// Determine if the PID is that of a strange baryon
  // PARTICLE_TO_PID_BOOLFN(isStrangeBaryon)
 
  // /// Determine if the PID is that of a strange hadron
  // PARTICLE_TO_PID_BOOLFN(isStrangeHadron)
 
 
 
  
  PARTICLE_TO_PID_BOOLFN(isReggeon)
 
  
  PARTICLE_TO_PID_BOOLFN(isDiquark)
 
  
  PARTICLE_TO_PID_BOOLFN(isPentaquark)
 
  
  PARTICLE_TO_PID_BOOLFN(isSUSY)
 
  
  PARTICLE_TO_PID_BOOLFN(isRhadron)
 
  
  PARTICLE_TO_PID_BOOLFN(isTechnicolor)
 
  
  PARTICLE_TO_PID_BOOLFN(isExcited)
 
  
  PARTICLE_TO_PID_BOOLFN(isKK)
 
  
  PARTICLE_TO_PID_BOOLFN(isGraviton)
 
  
  PARTICLE_TO_PID_BOOLFN(isBSM)
 
 
 
  
  PARTICLE_TO_PID_BOOLFN(isGenSpecific)
 
  
  PARTICLE_TO_PID_BOOLFN(isResonance)
 
  
  PARTICLE_TO_PID_BOOLFN(isTransportable)
 
 
 
  
  PARTICLE_TO_PID_BOOLFN(hasUp)
 
  
  PARTICLE_TO_PID_BOOLFN(hasDown)
 
  
  PARTICLE_TO_PID_BOOLFN(hasStrange)
 
  
  PARTICLE_TO_PID_BOOLFN(hasCharm)
 
  
  PARTICLE_TO_PID_BOOLFN(hasBottom)
 
  
  PARTICLE_TO_PID_BOOLFN(hasTop)
 
 
 
  
  PARTICLE_TO_PID_INTFN(jSpin)
 
  
  PARTICLE_TO_PID_INTFN(sSpin)
 
  
  PARTICLE_TO_PID_INTFN(lSpin)
 
 
  
  PARTICLE_TO_PID_DBLFN(charge)
 
  
  PARTICLE_TO_PID_INTFN(charge3)
 
  
  PARTICLE_TO_PID_DBLFN(abscharge)
 
  
  PARTICLE_TO_PID_INTFN(abscharge3)
 
  
  PARTICLE_TO_PID_INTFN(nuclZ)
 
  
  PARTICLE_TO_PID_INTFN(nuclA)
 
  
  PARTICLE_TO_PID_INTFN(nuclNlambda)
 
  
 
 
  
 
  inline bool isSameSign(const Particle& a, const Particle& b) { return PID::isSameSign(a.pid(), b.pid()); }
  inline bool isOppSign(const Particle& a, const Particle& b) { return PID::isOppSign(a.pid(), b.pid()); }
  inline bool isSameFlav(const Particle& a, const Particle& b) { return PID::isSameFlav(a.pid(), b.pid()); }
  inline bool isOppFlav(const Particle& a, const Particle& b) { return PID::isOppFlav(a.pid(), b.pid()); }
 
  inline bool isOSSF(const Particle& a, const Particle& b) { return PID::isOSSF(a.pid(), b.pid()); }
  inline bool isSSSF(const Particle& a, const Particle& b) { return PID::isSSSF(a.pid(), b.pid()); }
  inline bool isOSOF(const Particle& a, const Particle& b) { return PID::isOSOF(a.pid(), b.pid()); }
  inline bool isSSOF(const Particle& a, const Particle& b) { return PID::isSSOF(a.pid(), b.pid()); }
 
 
 
 
  inline bool oppSign(const Particle& a, const Particle& b) {
    return sign(a.charge3()) == -sign(b.charge3()) && sign(a.charge3()) != ZERO;
  }
 
  inline bool sameSign(const Particle& a, const Particle& b) {
    return sign(a.charge3()) == sign(b.charge3());
  }
 
  inline bool oppCharge(const Particle& a, const Particle& b) {
    return a.charge3() == -b.charge3() && a.charge3() != 0;
  }
 
  inline bool sameCharge(const Particle& a, const Particle& b) {
    return a.charge3() == b.charge3();
  }
 
  inline bool diffCharge(const Particle& a, const Particle& b) {
    return a.charge3() != b.charge3();
  }
 
 
 
 
 
 
 
 
  inline bool isFirstWith(const Particle& p, const ParticleSelector& f) {
    return p.isFirstWith(f);
  }
 
  inline bool isFirstWithout(const Particle& p, const ParticleSelector& f) {
    return p.isFirstWithout(f);
  }
 
 
  inline bool isLastWith(const Particle& p, const ParticleSelector& f) {
    return p.isLastWith(f);
  }
 
  inline bool isLastWithout(const Particle& p, const ParticleSelector& f) {
    return p.isLastWithout(f);
  }
 
 
 
  inline bool hasAncestorWith(const Particle& p, const ParticleSelector& f, bool only_physical=true) {
    return p.hasAncestorWith(f, only_physical);
  }
 
  inline bool hasAncestorWithout(const Particle& p, const ParticleSelector& f, bool only_physical=true) {
    return p.hasAncestorWithout(f, only_physical);
  }
 
 
  inline bool hasParentWith(const Particle& p, const ParticleSelector& f) {
    return p.hasParentWith(f);
  }
 
  inline bool hasParentWithout(const Particle& p, const ParticleSelector& f) {
    return p.hasParentWithout(f);
  }
 
 
  inline bool hasChildWith(const Particle& p, const ParticleSelector& f) {
    return p.hasChildWith(f);
  }
 
  inline bool hasChildWithout(const Particle& p, const ParticleSelector& f) {
    return p.hasChildWithout(f);
  }
 
 
  inline bool hasDescendantWith(const Particle& p, const ParticleSelector& f, bool remove_duplicates=true) {
    return p.hasDescendantWith(f, remove_duplicates);
  }
 
  inline bool hasDescendantWithout(const Particle& p, const ParticleSelector& f, bool remove_duplicates=true) {
    return p.hasDescendantWithout(f, remove_duplicates);
  }
 
 
  inline bool hasStableDescendantWith(const Particle& p, const ParticleSelector& f) {
    return p.hasStableDescendantWith(f);
  }
 
  inline bool hasStableDescendantWithout(const Particle& p, const ParticleSelector& f) {
    return p.hasStableDescendantWithout(f);
  }
 
 
 
  inline bool isVisible(const Particle& p) { return p.isVisible(); }
 
  inline bool isDirect(const Particle& p, bool allow_from_direct_tau=false, bool allow_from_direct_mu=false) {
    return p.isDirect(allow_from_direct_tau, allow_from_direct_mu);
  }
 
  inline bool isPrompt(const Particle& p, bool allow_from_prompt_tau=false, bool allow_from_prompt_mu=false) {
    return p.isPrompt(allow_from_prompt_tau, allow_from_prompt_mu);
  }
 
 
  inline bool isStable(const Particle& p) { return p.isStable(); }
 
  inline bool hasHadronicDecay(const Particle& p) {
    if (p.isStable()) return false;
    if (p.hasChildWith(isHadron)) return true;
    return false;
  }
 
  inline bool hasLeptonicDecay(const Particle& p) {
    if (p.isStable()) return false;
    if (p.hasChildWith(isHadron)) return false;
    return true;
  }
 
 
  inline bool fromBottom(const Particle& p) { return p.fromBottom(); }
 
  inline bool fromCharm(const Particle& p) { return p.fromCharm(); }
 
  inline bool fromHadron(const Particle& p) { return p.fromHadron(); }
 
  inline bool fromTau(const Particle& p, bool prompt_taus_only=false) {
    return p.fromTau(prompt_taus_only);
  }
 
  inline bool fromPromptTau(const Particle& p) { return p.fromPromptTau(); }
 
 
 
 
  struct BoolParticleFunctor {
    virtual bool operator()(const Particle& p) const = 0;
    virtual ~BoolParticleFunctor() {}
  };
 
  struct BoolParticleAND : public BoolParticleFunctor {
    BoolParticleAND(const std::vector<ParticleSelector>& sels) : selectors(sels) {}
    BoolParticleAND(const ParticleSelector& a, const ParticleSelector& b) : selectors({a,b}) {}
    BoolParticleAND(const ParticleSelector& a, const ParticleSelector& b, const ParticleSelector& c) : selectors({a,b,c}) {}
    bool operator()(const Particle& p) const {
      for (const ParticleSelector& sel : selectors) if (!sel(p)) return false;
      return true;
    }
    std::vector<ParticleSelector> selectors;
  };
  inline BoolParticleAND operator && (const ParticleSelector& a, const ParticleSelector& b) {
    return BoolParticleAND(a, b);
  }
 
 
  struct BoolParticleOR : public BoolParticleFunctor {
    BoolParticleOR(const std::vector<ParticleSelector>& sels) : selectors(sels) {}
    BoolParticleOR(const ParticleSelector& a, const ParticleSelector& b) : selectors({a,b}) {}
    BoolParticleOR(const ParticleSelector& a, const ParticleSelector& b, const ParticleSelector& c) : selectors({a,b,c}) {}
    bool operator()(const Particle& p) const {
      for (const ParticleSelector& sel : selectors) if (sel(p)) return true;
      return false;
    }
    std::vector<ParticleSelector> selectors;
  };
  inline BoolParticleOR operator || (const ParticleSelector& a, const ParticleSelector& b) {
    return BoolParticleOR(a, b);
  }
 
  struct BoolParticleNOT : public BoolParticleFunctor {
    BoolParticleNOT(const ParticleSelector& sel) : selector(sel) {}
    bool operator()(const Particle& p) const { return !selector(p); }
    ParticleSelector selector;
  };
  inline BoolParticleNOT operator ! (const ParticleSelector& a) {
    return BoolParticleNOT(a);
  }
 
 
  struct HasPID : public BoolParticleFunctor {
    HasPID(PdgId pid) : targetpids{pid} { }
    HasPID(vector<PdgId> pids) : targetpids{pids} { }
    HasPID(initializer_list<PdgId> pids) : targetpids{pids} { }
    bool operator()(const Particle& p) const { return contains(targetpids, p.pid()); }
    vector<PdgId> targetpids;
  };
  using hasPID = HasPID;
 
  struct HasAbsPID : public BoolParticleFunctor {
    HasAbsPID(PdgId pid) : targetapids{abs(pid)} { }
    HasAbsPID(vector<PdgId> pids) { for (PdgId pid : pids) targetapids.push_back(abs(pid)); }
    HasAbsPID(initializer_list<PdgId> pids) { for (PdgId pid : pids) targetapids.push_back(abs(pid)); }
    bool operator()(const Particle& p) const { return contains(targetapids, p.abspid()); }
    vector<PdgId> targetapids;
  };
  using hasAbsPID = HasAbsPID;
 
 
  struct FirstParticleWith : public BoolParticleFunctor {
    FirstParticleWith(const ParticleSelector& f) : fn(f) { }
    FirstParticleWith(const Cut& c);
    bool operator()(const Particle& p) const { return isFirstWith(p, fn); }
    ParticleSelector fn;
  };
  using firstParticleWith = FirstParticleWith;
 
  struct FirstParticleWithout : public BoolParticleFunctor {
    FirstParticleWithout(const ParticleSelector& f) : fn(f) { }
    FirstParticleWithout(const Cut& c);
    bool operator()(const Particle& p) const { return isFirstWithout(p, fn); }
    ParticleSelector fn;
  };
  using firstParticleWithout = FirstParticleWithout;
 
 
  struct LastParticleWith : public BoolParticleFunctor {
    template <typename FN>
    LastParticleWith(const FN& f) : fn(f) { }
    LastParticleWith(const Cut& c);
    bool operator()(const Particle& p) const { return isLastWith(p, fn); }
    std::function<bool(const Particle&)> fn;
  };
  using lastParticleWith = LastParticleWith;
 
  struct LastParticleWithout : public BoolParticleFunctor {
    LastParticleWithout(const ParticleSelector& f) : fn(f) { }
    LastParticleWithout(const Cut& c);
    bool operator()(const Particle& p) const { return isLastWithout(p, fn); }
    ParticleSelector fn;
  };
  using lastParticleWithout = LastParticleWithout;
 
 
  struct HasParticleAncestorWith : public BoolParticleFunctor {
    HasParticleAncestorWith(const ParticleSelector& f, bool only_physical=true) : fn(f), onlyphysical(only_physical) { }
    HasParticleAncestorWith(const Cut& c, bool only_physical=true);
    bool operator()(const Particle& p) const { return hasAncestorWith(p, fn, onlyphysical); }
    ParticleSelector fn;
    bool onlyphysical;
  };
  using hasParticleAncestorWith = HasParticleAncestorWith;
 
  struct HasParticleAncestorWithout : public BoolParticleFunctor {
    HasParticleAncestorWithout(const ParticleSelector& f, bool only_physical=true) : fn(f), onlyphysical(only_physical) { }
    HasParticleAncestorWithout(const Cut& c, bool only_physical=true);
    bool operator()(const Particle& p) const { return hasAncestorWithout(p, fn, onlyphysical); }
    ParticleSelector fn;
    bool onlyphysical;
  };
  using hasParticleAncestorWithout = HasParticleAncestorWithout;
 
 
  struct HasParticleParentWith : public BoolParticleFunctor {
    HasParticleParentWith(const ParticleSelector& f) : fn(f) { }
    HasParticleParentWith(const Cut& c);
    bool operator()(const Particle& p) const { return hasParentWith(p, fn); }
    ParticleSelector fn;
  };
  using hasParticleParentWith = HasParticleParentWith;
 
  struct HasParticleParentWithout : public BoolParticleFunctor {
    HasParticleParentWithout(const ParticleSelector& f) : fn(f) { }
    HasParticleParentWithout(const Cut& c);
    bool operator()(const Particle& p) const { return hasParentWithout(p, fn); }
    ParticleSelector fn;
  };
  using hasParticleParentWithout = HasParticleParentWithout;
 
 
  struct HasParticleChildWith : public BoolParticleFunctor {
    HasParticleChildWith(const ParticleSelector& f) : fn(f) { }
    HasParticleChildWith(const Cut& c);
    bool operator()(const Particle& p) const { return hasChildWith(p, fn); }
    ParticleSelector fn;
  };
  using hasParticleChildWith = HasParticleChildWith;
 
  struct HasParticleChildWithout : public BoolParticleFunctor {
    HasParticleChildWithout(const ParticleSelector& f) : fn(f) { }
    HasParticleChildWithout(const Cut& c);
    bool operator()(const Particle& p) const { return hasChildWithout(p, fn); }
    ParticleSelector fn;
  };
  using hasParticleChildWithout = HasParticleChildWithout;
 
 
  struct HasParticleDescendantWith : public BoolParticleFunctor {
    HasParticleDescendantWith(const ParticleSelector& f, bool remove_duplicates=true) : fn(f), rmduplicates(remove_duplicates) { }
    HasParticleDescendantWith(const Cut& c, bool remove_duplicates=true);
    bool operator()(const Particle& p) const { return hasDescendantWith(p, fn, rmduplicates); }
    ParticleSelector fn;
    bool rmduplicates;
  };
  using hasParticleDescendantWith = HasParticleDescendantWith;
 
  struct HasParticleDescendantWithout : public BoolParticleFunctor {
    HasParticleDescendantWithout(const ParticleSelector& f, bool remove_duplicates=true) : fn(f), rmduplicates(remove_duplicates) { }
    HasParticleDescendantWithout(const Cut& c, bool remove_duplicates=true);
    bool operator()(const Particle& p) const { return hasDescendantWithout(p, fn, rmduplicates); }
    ParticleSelector fn;
    bool rmduplicates;
  };
  using hasParticleDescendantWithout = HasParticleDescendantWithout;
 
 
 
 
  Particles& iselect(Particles& particles, const Cut& c);
 
  inline Particles select(const Particles& particles, const Cut& c) {
    Particles rtn = particles;
    return iselect(rtn, c);
  }
 
  inline Particles select(const Particles& particles, const Cut& c, Particles& out) {
    out = select(particles, c);
    return out;
  }
 
   Particles& idiscard(Particles& particles, const Cut& c);
 
  inline Particles discard(const Particles& particles, const Cut& c) {
    Particles rtn = particles;
    return idiscard(rtn, c);
  }
 
  inline Particles discard(const Particles& particles, const Cut& c, Particles& out) {
    out = discard(particles, c);
    return out;
  }
 
 
  // inline void ifilterIsolateDeltaR(Particles& particles, const FourMomenta& vecs) {
  //   ifilter_discard(particles,
  // }
 
 
  // inline Particles filterIsolateDeltaR(const Particles& particles, const FourMomenta& vecs) {
  // }
 
 
 
 
 
  inline PdgIdPair pids(const ParticlePair& pp) {
    return make_pair(pp.first.pid(), pp.second.pid());
  }
 
  namespace Kin {
  
    inline pair<double,double> energies(const ParticlePair& pp) {
      return make_pair(pp.first.E(), pp.second.E());
    }
   
    inline pair<FourMomentum,FourMomentum> moms(const ParticlePair& pp) {
      return make_pair(pp.first.mom(), pp.second.mom());
    }
 
    inline double mass(const ParticlePair& pp) {
      return mass(pp.first, pp.second);
    }
 
    inline double mass2(const ParticlePair& pp) {
      return mass2(pp.first, pp.second);
    }
 
    inline double mT(const ParticlePair& pp) {
      return mT(pp.first, pp.second);
    }
 
    inline double pT(const ParticlePair& pp) {
      return pT(pp.first, pp.second);
    }
 
  }  
  
 
 
 
  namespace Kin {
 
    inline double mass(const Particle& p, const FourMomentum& p4) {
      return mass(p.mom(), p4);
    }
 
    inline double mass(const FourMomentum& p4, const Particle& p) {
      return mass(p4, p.mom());
    }
 
    inline double mass(const Particle& p1, const Particle& p2) {
      return mass(p1.mom(), p2.mom());
    }
 
    inline double mass2(const Particle& p, const P4& p4) {
      return mass2(p.mom(), p4);
    }
 
    inline double mass2(const P4& p4, const Particle& p) {
      return mass2(p4, p.mom());
    }
 
    inline double mass2(const Particle& p1, const Particle& p2) {
      return mass2(p1.mom(), p2.mom());
    }
 
    inline double mT(const Particle& p, const P4& p4) {
      return mT(p.mom(), p4);
    }
 
    inline double mT(const P4& p4, const Particle& p) {
      return mT(p4, p.mom());
    }
 
    inline double mT(const Particle& p1, const Particle& p2) {
      return mT(p1.mom(), p2.mom());
    }
 
    inline double pT(const Particle& p, const P4& p4) {
      return pT(p.mom(), p4);
    }
 
    inline double pT(const P4& p4, const Particle& p) {
      return pT(p4, p.mom());
    }
 
    inline double pT(const Particle& p1, const Particle& p2) {
      return pT(p1.mom(), p2.mom());
    }
 
  }
 
 
 
  namespace Kin {
 
    inline double pT(const Particle& p) {
      return p.pT();
    }
 
    inline double sumPt(const Particles& ps) {
      return sum(ps, Kin::pT, 0.0);
    }
 
    inline FourMomentum sumP4(const Particles& ps) {
      return sum(ps, Kin::p4, FourMomentum());
    }
 
    inline Vector3 sumP3(const Particles& ps) {
      return sum(ps, Kin::p3, Vector3());
    }
 
 
 
  }
 
 
  // Import Kin namespace into Rivet
  using namespace Kin;
 
 
  inline bool isSame(const Particle& a, const Particle& b) {
    return a.isSame(b);
  }
  
 
 
  inline bool containsPID(const Particles& parts, int id, bool abs=false) {
    if (abs) return any(parts, HasAbsPID(id));
    return any(parts, HasPID(id));
  }
 
 
 
  inline bool isRadiative(const Particle& part) {
    const Particles& parents = part.parents();
    if (parents.size() != 1)
      return false;
 
    const Particle& mother = parents[0];
    return ( part.pid() != mother.pid() ) && ( containsPID(mother.children(), mother.pid()) );
  }
 
 
  bool cascadeContains( const Particles& parts,
            const vector<int>& pids,
                bool absolute,
            bool ignorephoton);
 
 
}
 
#endif