MatcherBase.h

// -*- C++ -*-
//
// MatcherBase.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_MatcherBase_H
#define ThePEG_MatcherBase_H
// This is the declaration of the MatcherBase class.
 
 
#include "ParticleData.h"
#include "ThePEG/EventRecord/Particle.h"
 
namespace ThePEG {
 
class MatcherBase: public Interfaced {
 
public:
 
  friend class Repository;
 
  typedef set<tPDPtr> tPDSet;
 
  typedef set<tPMPtr> tPMSet;
 
public:
 
  MatcherBase();
 
  MatcherBase(const MatcherBase &);
 
public:
 
  virtual bool check(const ParticleData &) const = 0;
 
  virtual PMPtr pmclone() const = 0;
 
  bool checkp(const Particle & p) const { return check(p.data()); }
 
  bool matches(const ParticleData & pd) const {
    return member(matchingParticles, PDPtr(const_cast<ParticleData *>(&pd)));
  }
 
 
  bool matches(const Particle & p) const { return matches(p.data()); }
  
  bool matches(const MatcherBase & pm) const {
    return member(matchingMatchers, PMPtr(const_cast<MatcherBase *>(&pm)));
  }
 
  const tPDSet & particles() const { return matchingParticles; }
  const tPMSet & matchers() const { return matchingMatchers; }
 
  Energy minMass() const { return theMinMass; }
 
  Energy maxMass() const { return theMaxMass; }
 
  Energy mass() const { return commonMass; }
 
  Energy width() const { return commonWidth; }
 
  Length cTau() const { return commonCTau; }
 
  PDT::Charge iCharge() const { return commonCharge; }
 
  bool charged() const { return PDT::charged(commonCharge); }
 
  bool positive() const { return PDT::positive(commonCharge); }
 
  bool negative() const { return PDT::negative(commonCharge); }
 
  PDT::Spin iSpin() const { return commonSpin; }
 
  PDT::Colour iColour() const { return commonColour; }
 
  bool coloured() const { return PDT::coloured(commonColour); }
 
  int stable() const { return commonStable; }
 
  tPMPtr CC() const { return theAntiPartner; }
 
public:
 
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual void doupdate();
 
protected:
 
  void addPIfMatch(tPDPtr);
 
  void addMIfMatch(tPMPtr);
 
  template <typename Iterator>
  void addPIfMatch(Iterator first, Iterator last) {
    for ( ; first != last; ++first ) addPIfMatch(*first);
  }
 
  template <typename Cont>
  void addPIfMatchFrom(const Cont & c) {
    addPIfMatch(c.begin(), c.end());
  }
 
  template <typename Iterator>
  void addMIfMatch(Iterator first, Iterator last) {
    for ( ; first != last; ++first ) addMIfMatch(*first);
  }
 
  template <typename Cont>
  void addMIfMatchFrom(const Cont & c) {
    addMIfMatch(c.begin(), c.end());
  }
 
  void clear();
 
  static void setCC(tPMPtr pm, tPMPtr apm) {
    pm->theAntiPartner = apm;
    apm->theAntiPartner = pm;
  }
 
private:
 
  tPDSet matchingParticles;
 
  tPMSet matchingMatchers;
 
  Energy theMaxMass;
 
  Energy theMinMass;
 
  Energy commonMass;
 
  Energy commonWidth;
 
  Length commonCTau;
 
  PDT::Charge commonCharge;
 
  PDT::Spin commonSpin;
 
  PDT::Colour commonColour;
 
  int commonStable;
 
  tPMPtr theAntiPartner;
 
private:
 
  static AbstractClassDescription<MatcherBase> initMatcherBase;
 
  MatcherBase & operator=(const MatcherBase &) = delete;
 
};
 
template <>
struct BaseClassTrait<MatcherBase,1>: public ClassTraitsType {
  typedef Interfaced NthBase;
};
 
template <>
struct ClassTraits<MatcherBase>:
    public ClassTraitsBase<MatcherBase> {
  static string className() { return "ThePEG::MatcherBase"; }
};
 
}
 
#endif /* ThePEG_MatcherBase_H */