diff --git a/Cuts/SimpleDISCut.cc b/Cuts/SimpleDISCut.cc --- a/Cuts/SimpleDISCut.cc +++ b/Cuts/SimpleDISCut.cc @@ -1,190 +1,224 @@ // -*- C++ -*- // // SimpleDISCut.cc is a part of ThePEG - Toolkit for HEP Event Generation // Copyright (C) 1999-2017 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. // // // This is the implementation of the non-inlined, non-templated member // functions of the SimpleDISCut class. // #include "SimpleDISCut.h" #include "ThePEG/Interface/ClassDocumentation.h" #include "ThePEG/Interface/Parameter.h" #include "ThePEG/Interface/Switch.h" #include "ThePEG/PDT/ParticleData.h" #include "ThePEG/Cuts/Cuts.h" #include "ThePEG/Persistency/PersistentOStream.h" #include "ThePEG/Persistency/PersistentIStream.h" #include "ThePEG/Repository/CurrentGenerator.h" using namespace ThePEG; void SimpleDISCut::describe() const { CurrentGenerator::log() << fullName() << ":\n" << "Q2 = " << theMinQ2/GeV2 << " .. " << theMaxQ2/GeV2 << " GeV2\n" + << "y = " << theMiny << " .. " << theMaxy << " \n" << "W2 = " << theMinW2/GeV2 << " .. " << theMaxW2/GeV2 << " GeV2\n\n"; } IBPtr SimpleDISCut::clone() const { return new_ptr(*this); } IBPtr SimpleDISCut::fullclone() const { return new_ptr(*this); } bool SimpleDISCut::check(long idi, long ido) const { if ( abs(idi) <= 10 || abs(idi) > 16 ) return false; if ( idi*ido <= 0 ) return false; if ( chargedCurrent ) { if ( abs(idi)%2 ) return abs(idi) == abs(ido) - 1; else return abs(idi) == abs(ido) + 1; } else { return ( idi == ido ); } } Energy2 SimpleDISCut::minTij(tcPDPtr pi, tcPDPtr po) const { if ( !check(pi->id(), po->id()) ) return ZERO; return theMinQ2; } bool SimpleDISCut::passCuts(tcCutsPtr cuts, tcPDPtr pitype, tcPDPtr pjtype, LorentzMomentum pi, LorentzMomentum pj, bool inci, bool incj) const { if ( inci ) { if ( incj ) return true; if ( !check(pitype->id(), pjtype->id()) ) return true; Energy2 Q2 = -(pi - pj).m2(); double x = min(1.0, sqrt(cuts->currentSHat()/cuts->SMax())* exp(-cuts->currentYHat())); Energy2 W2 = (1.0 - x)*Q2/x; - return Q2 > theMinQ2 && Q2 < theMaxQ2 && W2 > theMinW2 && W2 < theMaxW2; + double y = Q2/cuts->SMax()/x; + return y > theMiny && y < theMaxy && Q2 > theMinQ2 && Q2 < theMaxQ2 + && W2 > theMinW2 && W2 < theMaxW2; } else if ( incj ) { if ( !check(pjtype->id(), pitype->id()) ) return true; Energy2 Q2 = -(pj - pi).m2(); double x = min(1.0, sqrt(cuts->currentSHat()/cuts->SMax())* exp(cuts->currentYHat())); Energy2 W2 = (1.0 - x)*Q2/x; - return Q2 > theMinQ2 && Q2 < theMaxQ2 && W2 > theMinW2 && W2 < theMaxW2; + double y = Q2/cuts->SMax()/x; + return y > theMiny && y < theMaxy && Q2 > theMinQ2 && Q2 < theMaxQ2 + && W2 > theMinW2 && W2 < theMaxW2; } return true; } Energy2 SimpleDISCut::minSij(tcPDPtr, tcPDPtr) const { return ZERO; } double SimpleDISCut::minDeltaR(tcPDPtr, tcPDPtr) const { return 0.0; } Energy SimpleDISCut::minKTClus(tcPDPtr, tcPDPtr) const { return ZERO; } double SimpleDISCut::minDurham(tcPDPtr, tcPDPtr) const { return 0.0; } void SimpleDISCut::persistentOutput(PersistentOStream & os) const { os << ounit(theMinQ2, GeV2) << ounit(theMaxQ2, GeV2) + << theMiny << theMaxy << ounit(theMinW2, GeV2) << ounit(theMaxW2, GeV2) << chargedCurrent; } void SimpleDISCut::persistentInput(PersistentIStream & is, int) { is >> iunit(theMinQ2, GeV2) >> iunit(theMaxQ2, GeV2) + >> theMiny >> theMaxy >> iunit(theMinW2, GeV2) >> iunit(theMaxW2, GeV2) >> chargedCurrent; } ClassDescription SimpleDISCut::initSimpleDISCut; // Definition of the static class description member. +double SimpleDISCut::maxMiny() const { + return theMaxy; +} + +double SimpleDISCut::minMaxy() const { + return theMiny; +} + Energy2 SimpleDISCut::maxMinQ2() const { return theMaxQ2; } Energy2 SimpleDISCut::minMaxQ2() const { return theMinQ2; } Energy2 SimpleDISCut::maxMinW2() const { return theMaxW2; } Energy2 SimpleDISCut::minMaxW2() const { return theMinW2; } void SimpleDISCut::Init() { - + typedef double (ThePEG::SimpleDISCut::*IGFN)() const; + typedef void (ThePEG::SimpleDISCut::*ISFN)(double); static ClassDocumentation documentation ("SimpleDISCut inherits from TwoCutBase and omplements a simple " "\\f$Q^2\\f$ cut on the a scattered lepton, either neutral or charged " "current."); static Parameter interfaceMinQ2 ("MinQ2", "The minimum \\f$Q^2\\f$.", &SimpleDISCut::theMinQ2, GeV2, 1.0*GeV2, ZERO, Constants::MaxEnergy2, true, false, Interface::limited, 0, 0, 0, &SimpleDISCut::maxMinQ2, 0); static Parameter interfaceMaxQ2 ("MaxQ2", "The maximum \\f$Q^2\\f$. Note that this is only applied as a post-cut " "and will not affect the initial phase space cuts in the generation.", &SimpleDISCut::theMaxQ2, GeV2, 100.0*GeV2, ZERO, ZERO, true, false, Interface::lowerlim, 0, 0, &SimpleDISCut::minMaxQ2, 0, 0); + static Parameter interfaceMiny + ("Miny", + "The minimum \\f$y\\f$.", + &SimpleDISCut::theMiny, 0.0, 0.0, 1.0, + true, false, Interface::limited, + (ISFN)0, (IGFN)0, (IGFN)0, &SimpleDISCut::maxMiny, (IGFN)0); + + static Parameter interfaceMaxy + ("Maxy", + "The maximum \\f$y\\f$. Note that this is only applied as a post-cut " + "and will not affect the initial phase space cuts in the generation.", + &SimpleDISCut::theMaxy, 0.0, 0.0, 1.0, + true, false, Interface::lowerlim, + (ISFN)0, (IGFN)0, &SimpleDISCut::minMaxy, (IGFN)0, (IGFN)0); + static Parameter interfaceMinW2 ("MinW2", "The minimum \\f$W^2\\f$. Note that this is only applied as a post-cut " "and will not affect the initial phase space cuts in the generation.", &SimpleDISCut::theMinW2, GeV2, 100.0*GeV2, ZERO, Constants::MaxEnergy2, true, false, Interface::limited, 0, 0, 0, &SimpleDISCut::maxMinW2, 0); static Parameter interfaceMaxW2 ("MaxW2", "The maximum \\f$W^2\\f$. Note that this is only applied as a post-cut " "and will not affect the initial phase space cuts in the generation.", &SimpleDISCut::theMaxW2, GeV2, 1000000.0*GeV2, ZERO, ZERO, true, false, Interface::lowerlim, 0, 0, &SimpleDISCut::minMaxW2, 0, 0); static Switch interfaceCurrent ("Current", "Determines whether this cut should be applied to charged or neutral " "current events.", &SimpleDISCut::chargedCurrent, false, true, false); static SwitchOption interfaceCurrentCharged (interfaceCurrent, "Charged", "The cut is only applied to charged current events.", true); static SwitchOption interfaceCurrentNeutral (interfaceCurrent, "Neutral", "The cut is only applied to neutral current events.", false); - + interfaceMiny.rank(12); + interfaceMaxy.rank(11); interfaceMinQ2.rank(10); interfaceMaxQ2.rank(9); interfaceCurrent.rank(8); + interfaceMiny.setHasDefault(false); + interfaceMaxy.setHasDefault(false); interfaceMinQ2.setHasDefault(false); interfaceMaxQ2.setHasDefault(false); interfaceMinW2.setHasDefault(false); interfaceMaxW2.setHasDefault(false); interfaceCurrent.setHasDefault(false); } diff --git a/Cuts/SimpleDISCut.h b/Cuts/SimpleDISCut.h --- a/Cuts/SimpleDISCut.h +++ b/Cuts/SimpleDISCut.h @@ -1,249 +1,271 @@ // -*- C++ -*- // // SimpleDISCut.h is a part of ThePEG - Toolkit for HEP Event Generation // Copyright (C) 1999-2017 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_SimpleDISCut_H #define THEPEG_SimpleDISCut_H // // This is the declaration of the SimpleDISCut class. // #include "ThePEG/Cuts/TwoCutBase.h" namespace ThePEG { /** * SimpleDISCut inherits from TwoCutBase and omplements a simple * \f$Q^2\f$ cut on the a scattered lepton, either neutral or charged * current. * * @see \ref SimpleDISCutInterfaces "The interfaces" * defined for SimpleDISCut. */ class SimpleDISCut: public TwoCutBase { public: /** * The default constructor. */ SimpleDISCut() - : theMinQ2(1.0*GeV2), theMaxQ2(100.0*GeV2), + : theMinQ2(1.0*GeV2), theMaxQ2(100.0*GeV2),theMiny(0.0), theMaxy(1.0), theMinW2(100.0*GeV2), theMaxW2(1000000.0*GeV2), chargedCurrent(false) {} public: /** @name Overridden virtual functions defined in the base class. */ //@{ /** * Return the minimum allowed squared invariant mass of two outgoing * partons of type \a pi and \a pj. Returns zero. */ virtual Energy2 minSij(tcPDPtr pi, tcPDPtr pj) const; /** * Return the minimum allowed value of the negative of the squared * invariant mass of an incoming parton of type \a pi and an * outgoing parton of type \a po. Return the minimum \f$Q^2\f$ if * the incoming and outgoing particles are matching leptons. */ virtual Energy2 minTij(tcPDPtr pi, tcPDPtr po) const; /** * Return the minimum allowed value of \f$\Delta * R_{ij}=\sqrt{\Delta\eta_{ij}^2+\Delta\phi_{ij}^2}\f$ of two * outgoing partons of type \a pi and \a pj. Returns zero. */ virtual double minDeltaR(tcPDPtr pi, tcPDPtr pj) const; /** * Return the minimum allowed value of the longitudinally invariant * \f$k_\perp\f$-algorithms distance measure. This is defined as * \f$\min(p_{\perp i}, p_{\perp * j})\sqrt{\Delta\eta_{ij}^2+\Delta\phi_{ij}^2}\f$ for two outgoing * partons, or simply \f$p_{\perp i}\f$ or \f$p_{\perp j}\f$ for a * single outgoing parton. Returns 0 if both partons are incoming. A * null pointer indicates an incoming parton, hence the type of the * incoming parton is irrelevant. Returns zero. */ virtual Energy minKTClus(tcPDPtr pi, tcPDPtr pj) const; /** * Return the minimum allowed value of the Durham * \f$k_\perp\f$-algorithms distance measure. This is defined as * \f$2\min(E_j^2, E_j^2)(1-\cos\theta_{ij})/\hat{s}\f$ for two * outgoing partons. Returns zero. */ virtual double minDurham(tcPDPtr pi, tcPDPtr pj) const; /** * Return true if a pair of particles with type \a pitype and \a * pjtype and momenta \a pi and \a pj respectively passes the * cuts. \a inci and \a inj indicates if the corresponding particles * are incoming. */ virtual bool passCuts(tcCutsPtr parent, tcPDPtr pitype, tcPDPtr pjtype, LorentzMomentum pi, LorentzMomentum pj, bool inci = false, bool incj = false) const; //@} /** * Describe the currently active cuts in the log file. */ virtual void describe() const; protected: /** * Check that the types of the incoming and outgoing particle types * matches a DIS event. */ bool check(long idi, long ido) const; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} private: /** * Helper function used by the interface. */ + double maxMiny() const; + + /** + * Helper function used by the interface. + */ + double minMaxy() const; + + /** + * Helper function used by the interface. + */ Energy2 maxMinQ2() const; /** * Helper function used by the interface. */ Energy2 minMaxQ2() const; /** * Helper function used by the interface. */ Energy2 maxMinW2() const; /** * Helper function used by the interface. */ Energy2 minMaxW2() const; private: /** * The minimum \f$Q^2\f$. */ Energy2 theMinQ2; /** * The maximum \f$Q^2\f$. This is only applied as a post-cut. */ Energy2 theMaxQ2; /** + * The minimum \f$y\f$. + */ + double theMiny; + + /** + * The maximum \f$y\f$. This is only applied as a post-cut. + */ + double theMaxy; + + + + /** * The minimum \f$W^2\f$. This is only applied as a post-cut. */ Energy2 theMinW2; /** * The maximum \f$W^2\f$. This is only applied as a post-cut. */ Energy2 theMaxW2; /** * If true the cut is applied to charged current events, otherwise * it is applied to neutral current events. */ bool chargedCurrent; private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initSimpleDISCut; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ SimpleDISCut & operator=(const SimpleDISCut &) = delete; }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of SimpleDISCut. */ template <> struct BaseClassTrait { /** Typedef of the first base class of SimpleDISCut. */ typedef TwoCutBase NthBase; }; /** This template specialization informs ThePEG about the name of * the SimpleDISCut class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "ThePEG::SimpleDISCut"; } /** Return the name of the shared library be loaded to get * access to the SimpleDISCut class and every other class it uses * (except the base class). */ static string library() { return "SimpleDISCut.so"; } }; /** @endcond */ } #endif /* THEPEG_SimpleDISCut_H */