StandardMatchers.h

Go to the documentation of this file.

// -*- C++ -*-
//
// StandardMatchers.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_StandardMatchers_H
#define ThePEG_StandardMatchers_H
// This is the declaration of the AnyMatcher,
 
 
#include "Matcher.h"
#include "ThePEG/PDT/EnumParticles.h"
 
namespace ThePEG {
 
struct AnyMatcher: public MatcherType {
  typedef AnyMatcher CC;
  static bool Check(const ParticleData & pd) {
    return bool(pd.id());
  }
  static string className() { return "Any"; }
};
typedef Matcher<AnyMatcher> MatchAny;
 
 
struct ChargedMatcher: public MatcherType {
  typedef ChargedMatcher CC;
  static bool Check(const ParticleData & pd) {
    return PDT::charged(pd.iCharge());
  }
  static string className() { return "Charged"; }
};
typedef Matcher<ChargedMatcher> MatchCharged;
 
struct NegativeMatcher;
 
struct PositiveMatcher: public MatcherType {
  typedef NegativeMatcher CC;
  static bool Check(const ParticleData & pd) {
    return PDT::positive(pd.iCharge());
  }
  static string className() { return "Positive"; }
};
typedef Matcher<PositiveMatcher> MatchPositive;
 
 
struct NeutralMatcher: public MatcherType {
  typedef NeutralMatcher CC;
  static bool Check(const ParticleData & pd) {
    return pd.iCharge() == PDT::Charge0;
  }
  static string className() { return "Neutral"; }
};
typedef Matcher<NeutralMatcher> MatchNeutral;
 
struct NegativeMatcher: public MatcherType {
  typedef PositiveMatcher CC;
  static bool Check(const ParticleData & pd) {
    return PDT::negative(pd.iCharge());
  }
  static string className() { return "Negative"; }
};
typedef Matcher<NegativeMatcher> MatchNegative;
 
struct BaryonMatcher: public MatcherType {
  typedef BaryonMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return (id/10)%10 && (id/100)%10 && (id/1000)%10;
  }
  static string className() { return "Baryon"; }
};
typedef Matcher<BaryonMatcher> MatchBaryon;
 
 
struct MesonMatcher: public MatcherType {
  typedef MesonMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return (id/10)%10 && (id/100)%10 && (id/1000)%10 == 0;
  }
  static string className() { return "Meson"; }
};
typedef Matcher<MesonMatcher> MatchMeson;
 
 
struct DiquarkMatcher: public MatcherType {
  typedef DiquarkMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return id/10 && (id/10)%10 == 0 && (id/100)%10 && (id/1000)%10;
  }
  static string className() { return "Diquark"; }
};
typedef Matcher<DiquarkMatcher> MatchDiquark;
 
struct QuarkMatcher: public MatcherType {
  typedef QuarkMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return id && abs(id) < 10;
  }
  static string className() { return "Quark"; }
};
typedef Matcher<QuarkMatcher> MatchQuark;
 
struct LeptonMatcher: public MatcherType {
  typedef LeptonMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return abs(id) > 10 && abs(id) <= 20;
  }
  static string className() { return "Lepton"; }
};
typedef Matcher<LeptonMatcher> MatchLepton;
 
struct NeutrinoMatcher: public MatcherType {
  typedef NeutrinoMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return abs(id)-10 >= 2 && abs(id)-10 <= 8 && abs(id)%2 == 0;
  }
  static string className() { return "Neutrino"; }
};
 
typedef Matcher<NeutrinoMatcher> MatchNeutrino;
 
struct LightAntiQuarkMatcher;
 
struct LightQuarkMatcher: public MatcherType {
  typedef LightAntiQuarkMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return id > 0 && id < 4 ;
  }
  static string className() { return "LightQuark"; }
};
typedef Matcher<LightQuarkMatcher> MatchLightQuark;
 
 
struct LightAntiQuarkMatcher: public MatcherType {
  typedef LightQuarkMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return id < 0 && id > -4 ;
  }
  static string className() { return "LightAntiQuark"; }
};
typedef Matcher<LightAntiQuarkMatcher> MatchLightAntiQuark;
 
struct StandardQCDPartonMatcher: public MatcherType {
  typedef StandardQCDPartonMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return id && ( abs(id) <= 5 || id == ParticleID::g );
  }
  static string className() { return "StandardQCDParton"; }
};
 
typedef Matcher<StandardQCDPartonMatcher> MatchStandardQCDParton;
 
struct PseudoScalarMesonMatcher: public MatcherType {
  typedef PseudoScalarMesonMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return ( (abs(id)/1000)%1 == 0 && abs(id) > 100 && abs(id)%10 == 1 ) ||
      ( id == ParticleID::K_L0 || id == ParticleID::K_S0 );
  }
  static string className() { return "PseudoScalarMeson"; }
};
 
typedef Matcher<PseudoScalarMesonMatcher> MatchPseudoScalarMeson;
 
 
struct VectorMesonMatcher: public MatcherType {
  typedef VectorMesonMatcher CC;
  static bool Check(const ParticleData & pd) { return Check(pd.id()); }
  static bool Check(long id) {
    return (abs(id)/1000)%1 == 0 && abs(id) > 100 && abs(id)%10 == 3;
  }
  static string className() { return "VectorMeson"; }
};
 
typedef Matcher<VectorMesonMatcher> MatchVectorMeson;
 
}
 
#endif /* ThePEG_StandardMatchers_H */