Cuts.h

// -*- C++ -*-
//
// Cuts.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_Cuts_H
#define THEPEG_Cuts_H
//
// This is the declaration of the Cuts class.
//
 
#include "ThePEG/Interface/Interfaced.h"
#include "Cuts.fh"
#include "OneCutBase.h"
#include "TwoCutBase.h"
#include "MultiCutBase.h"
#include "JetFinder.h"
#include "FuzzyTheta.h"
 
namespace ThePEG {
 
class Cuts: public Interfaced {
 
public:
 
  typedef vector<OneCutPtr> OneCutVector;
 
  typedef vector<TwoCutPtr> TwoCutVector;
 
  typedef vector<MultiCutPtr> MultiCutVector;
 
public:
 
  Cuts(Energy MhatMin=2*GeV);
 
public:
 
  virtual void initialize(Energy2 smax, double Y);
 
  virtual void initEvent();
 
  virtual bool
  initSubProcess(Energy2 shat, double yhat, bool mirror = false) const;
 
  virtual bool passCuts(const tcPDVector & ptype, const vector<LorentzMomentum> & p,
                        tcPDPtr t1 = tcPDPtr(), tcPDPtr t2 = tcPDPtr()) const;
 
  bool passCuts(const tcPVector & p,
                tcPDPtr t1 = tcPDPtr(), tcPDPtr t2 = tcPDPtr()) const;
 
  bool passCuts(const SubProcess & sub) const;
 
  bool passCuts(const Collision & coll) const;
 
  Energy2 minSij(tcPDPtr pi, tcPDPtr pj) const;
 
  Energy2 minTij(tcPDPtr pi, tcPDPtr po) const;
 
  double minDeltaR(tcPDPtr pi, tcPDPtr pj) const;
 
  Energy minKTClus(tcPDPtr pi, tcPDPtr pj) const;
 
  double minDurham(tcPDPtr pi, tcPDPtr pj) const;
 
  Energy minKT(tcPDPtr p) const;
 
  double minEta(tcPDPtr p) const;
 
  double maxEta(tcPDPtr p) const;
 
  double minRapidityMax(tcPDPtr p) const;
 
  double maxRapidityMin(tcPDPtr p) const;
 
  double minYStar(tcPDPtr p) const;
 
  double maxYStar(tcPDPtr p) const;
 
  Energy2 minS(const tcPDVector & pv) const;
 
  Energy2 maxS(const tcPDVector & pv) const;
 
  template <typename T>
  vector<typename Ptr<T>::transient_const_pointer>
  oneCutObjects() const;
 
  template <typename T>
  vector<typename Ptr<T>::transient_const_pointer>
  twoCutObjects() const;
 
  template <typename T>
  vector<typename Ptr<T>::transient_const_pointer>
  multiCutObjects() const;
 
  const OneCutVector& oneCuts() const { return theOneCuts; }
 
  const TwoCutVector& twoCuts() const { return theTwoCuts; }
 
  const MultiCutVector& multiCuts() const { return theMultiCuts; }
 
  Ptr<JetFinder>::tptr jetFinder() const { return theJetFinder; }
 
  void add(tOneCutPtr c) { theOneCuts.push_back(c); }
 
  void add(tTwoCutPtr c) { theTwoCuts.push_back(c); }
 
  void add(tMultiCutPtr c) { theMultiCuts.push_back(c); }
 
public:
 
  Energy2 SMax() const { return theSMax; }
 
 
  double Y() const { return theY; }
 
  Energy2 currentSHat() const { return theCurrentSHat; }
 
  double currentYHat() const { return theCurrentYHat; }
 
 
  Energy2 sHatMin() const { return max(sqr(theMHatMin), theX1Min*theX2Min*SMax()); }
 
  Energy2 sHatMax() const { return min(sqr(theMHatMax), theX1Max*theX2Max*SMax()); }
 
  bool sHat(Energy2 sh) const { 
    return sh > sHatMin() && sh <= sHatMax()*(1.0 + 1000.0*Constants::epsilon);
  }
 
  Energy mHatMin() const { return max(theMHatMin, sqrt(theX1Min*theX2Min*SMax())); }
 
  Energy mHatMax() const { return min(theMHatMax, sqrt(theX1Max*theX2Max*SMax())); }
 
  double yHatMin() const;
 
  double yHatMax() const;
 
  bool yHat(double y) const;
 
  double x1Min() const;
 
  double x1Max() const;
 
  bool x1(double x) const;
 
  double x2Min() const;
 
  double x2Max() const;
 
  bool x2(double x) const;
 
  Energy2 scaleMin() const { return theScaleMin; }
 
  Energy2 scaleMax() const { return theScaleMax; }
 
  bool scale(Energy2 Q2) const { return Q2 > scaleMin() && Q2 < scaleMax(); }
 
  bool subMirror() const { return theSubMirror; }
 
  double cutWeight() const { return theCutWeight; }
 
  void lastCutWeight(double w) const { theLastCutWeight = w; }
 
  Ptr<FuzzyTheta>::tcptr fuzzy() const { return theFuzzyTheta; }
 
  template<class CutType, class Value>
  bool isInside(const Value& v, const Value& lower, const Value& upper, double& weight) const {
    if ( !fuzzy() ) {
      if ( v >= lower && v <= upper )
        return true;
      weight = 0.0;
      return false;
    }
    return fuzzy()->isInside<CutType>(v,lower,upper,weight);
  }
 
  template<class CutType, class Value>
  bool isLessThan(const Value& v, const Value& upper, double& weight) const {
    if ( !fuzzy() ) {
      if ( v <= upper )
        return true;
      weight = 0.0;
      return false;
    }
    return fuzzy()->isLessThan<CutType>(v,upper,weight);
  }
 
  template<class CutType, class Value>
  bool isLargerThan(const Value& v, const Value& lower, double& weight) const {
    if ( !fuzzy() ) {
      if ( v >= lower )
        return true;
      weight = 0.0;
      return false;
    }
    return fuzzy()->isLargerThan<CutType>(v,lower,weight);
  }
 
public:
 
  virtual void describe() const;
 
protected:
 
  virtual void doinitrun();
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
private:
 
  Energy maxMHatMin() const;
 
  Energy minMHatMax() const;
 
  double maxYHatMin() const;
 
  double minYHatMax() const;
 
  double maxX1Min() const;
 
  double minX1Max() const;
 
  double maxX2Min() const;
 
  double minX2Max() const;
 
  Energy2 maxScaleMin() const;
 
  Energy2 minScaleMax() const;
 
private:
 
  Energy2 theSMax;
 
  double theY;
 
  mutable Energy2 theCurrentSHat;
 
  mutable double theCurrentYHat;
 
  Energy theMHatMin;
 
  Energy theMHatMax;
 
  double theYHatMin;
 
  double theYHatMax;
 
  double theX1Min;
 
  double theX1Max;
 
  double theX2Min;
 
  double theX2Max;
 
  Energy2 theScaleMin;
 
  Energy2 theScaleMax;
 
  OneCutVector theOneCuts;
 
  TwoCutVector theTwoCuts;
 
  MultiCutVector theMultiCuts;
 
  Ptr<JetFinder>::ptr theJetFinder;
 
  mutable bool theSubMirror;
 
  mutable double theCutWeight;
 
  mutable double theLastCutWeight;
 
  Ptr<FuzzyTheta>::ptr theFuzzyTheta;
 
private:
 
  static ClassDescription<Cuts> initCuts;
 
  Cuts & operator=(const Cuts &) = delete;
 
};
 
}
 
#include "ThePEG/Utilities/ClassTraits.h"
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<Cuts,1> {
  typedef Interfaced NthBase;
};
 
template <>
struct ClassTraits<Cuts>
  : public ClassTraitsBase<Cuts> {
  static string className() { return "ThePEG::Cuts"; }
};
 
}
 
#endif /* THEPEG_Cuts_H */