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

  virtual ~Cuts();

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