SelectorBase.h

// -*- C++ -*-
//
// SelectorBase.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_SelectorBase_H
#define ThePEG_SelectorBase_H
// This is the declaration of the SelectorBase class.
 
 
#include "EventConfig.h"
 
namespace ThePEG {
 
class SelectorBase {
 
public:
 
  virtual ~SelectorBase() {}
 
  static bool Check(const Particle &) { return true; }
 
  static bool Intermediate() { return true; }
 
  static bool FinalState() { return true; }
 
  static bool AllSteps() { return true; }
 
  static bool AllCollisions() { return true; }
 
  virtual bool check(const Particle &  p) const { return Check(p); }
 
  virtual bool finalState() const { return FinalState(); }
 
  virtual bool intermediate() const { return Intermediate(); }
 
  virtual bool allSteps() const { return AllSteps(); }
 
  virtual bool allCollisions() const { return AllCollisions(); }
 
};
 
template <class T>
struct ParticleSelector: public SelectorBase {
 
  static bool Check(const Particle & p) { return T::Check(p); }
 
  static bool Intermediate() { return T::Intermediate(); }
 
  static bool FinalState() { return T::FinalState(); }
 
  static bool AllSteps() { return T::AllSteps(); }
 
  static bool AllCollisions() { return T::AllCollisions(); }
 
  virtual bool check(const Particle &  p) const { return Check(p); }
 
  virtual bool finalState() const { return FinalState(); }
 
  virtual bool intermediate() const { return Intermediate(); }
 
  virtual bool allSteps() const { return AllSteps(); }
 
  virtual bool allCollisions() const { return AllCollisions(); }
 
};  
 
class SelectIfNot: public SelectorBase {
 
public:
 
  explicit SelectIfNot(const SelectorBase & S) : s(S) {}
 
  virtual bool check(const Particle &  p) const { return !s.check(p); }
 
  virtual bool finalState() const { return !s.finalState(); }
 
  virtual bool intermediate() const { return !s.intermediate(); }
 
  virtual bool allSteps() const { return !s.allSteps(); }
 
  virtual bool allCollisions() const { return !s.allCollisions(); }
 
private:
 
  const SelectorBase & s;
};
 
class SelectIfBoth: public SelectorBase {
 
public:
 
  SelectIfBoth(const SelectorBase & S1, const SelectorBase & S2)
    : s1(S1), s2(S2) {}
 
  virtual bool check(const Particle &  p) const {
    return s1.check(p) && s2.check(p);
  }
 
  virtual bool finalState() const {
    return s1.finalState() && s2.finalState();
  }
 
  virtual bool intermediate() const {
    return s1.intermediate() && s2.intermediate();
  }
 
  virtual bool allSteps() const {
    return s1.allSteps() && s2.allSteps();
  }
 
  virtual bool allCollisions() const {
    return s1.allCollisions() && s2.allCollisions();
  }
 
private:
 
  const SelectorBase & s1;
 
  const SelectorBase & s2;
 
};
 
class SelectIfEither: public SelectorBase {
 
public:
 
  SelectIfEither(const SelectorBase & S1, const SelectorBase & S2)
    : s1(S1), s2(S2) {}
 
  virtual bool check(const Particle &  p) const {
    return s1.check(p) || s2.check(p);
  }
 
  virtual bool finalState() const {
    return s1.finalState() || s2.finalState();
  }
 
  virtual bool intermediate() const {
    return s1.intermediate() || s2.intermediate();
  }
 
  virtual bool allSteps() const {
    return s1.allSteps() || s2.allSteps();
  }
 
  virtual bool allCollisions() const {
    return s1.allCollisions() || s2.allCollisions();
  }
 
private:
 
  const SelectorBase & s1;
 
  const SelectorBase & s2;
 
};
 
template <typename OutputIterator, typename Container>
inline void copyIfCheck(OutputIterator r, const Container & c,
                        const SelectorBase & s) {
  for ( typename Container::const_iterator it = c.begin();
        it != c.end(); ++it )
    if ( s.check(**it) ) *r++ = *it;
}
 
}
 
#endif /* ThePEG_SelectorBase_H */