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 */