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 &);

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