PYTHIA8/pythia8130/include/UserHooks.h

   1 // UserHooks.h is a part of the PYTHIA event generator.
   2 // Copyright (C) 2008 Torbjorn Sjostrand.
   3 // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
   4 // Please respect the MCnet Guidelines, see GUIDELINES for details.
   5
   6 // Header file to allow user access to program at different stages.
   7 // UserHooks: almost empty base class, with user to write the rela code.
   8 // MyUserHooks: derived class, only intended as an example.
   9
  10 #ifndef Pythia8_UserHooks_H
  11 #define Pythia8_UserHooks_H
  12
  13 #include "Event.h"
  14 #include "PhaseSpace.h"
  15 #include "PythiaStdlib.h"
  16 #include "SigmaProcess.h"
  17
  18 namespace Pythia8 {
  19
  20 //**************************************************************************
  21
  22 // Forward reference to the PhaseSpace class.
  23 class PhaseSpace;
  24
  25 //**************************************************************************
  26
  27 // UserHooks is base class for user access to program execution.
  28
  29 class UserHooks {
  30
  31 public:
  32
  33   // Destructor.
  34   virtual ~UserHooks() {}
  35
  36   // Possibility to modify cross section of process.
  37   virtual bool canModifySigma() {return false;}
  38
  39   // Multiplicative factor modifying the cross section of a hard process.
  40   virtual double multiplySigmaBy(const SigmaProcess* sigmaProcessPtr,
  41     const PhaseSpace* phaseSpacePtr, bool inEvent);
  42
  43   // Possibility to veto event after process-level selection.
  44   virtual bool canVetoProcessLevel() {return false;}
  45
  46   // Decide whether to veto current process or not, based on process record.
  47   // Usage: doVetoProcessLevel( process).
  48   virtual bool doVetoProcessLevel( const Event& ) {return false;}
  49
  50   // Possibility to veto MI + ISR + FSR evolution and kill event,
  51   // making decision at a fixed pT scale. Useful for MLM-style matching.
  52   virtual bool canVetoPT() {return false;}
  53
  54   // Transverse-momentum scale for veto test.
  55   virtual double scaleVetoPT() {return 0.;}
  56
  57   // Decide whether to veto current event or not, based on event record.
  58   // Usage: doVetoPT( iPos, event), where iPos = 0: no emissions so far;
  59   // iPos = 1/2/3 joint evolution, latest step was MI/ISR/FSR;
  60   // iPos = 4: FSR only afterwards; iPos = 5: FSR in resonance decay.
  61   virtual bool doVetoPT( int , const Event& ) {return false;}
  62
  63   // Possibility to veto MI + ISR + FSR evolution and kill event,
  64   // making decision after fixed number of ISR or FSR steps.
  65   virtual bool canVetoStep() {return false;}
  66
  67   // Up to how many steps should be checked.
  68   virtual int numberVetoStep() {return 1;}
  69
  70   // Decide whether to veto current event or not, based on event record.
  71   // Usage: doVetoStep( iPos, nISR, nFSR, event), where iPos as above,
  72   // nISR and nFSR number of emissions so far for hard interaction only.
  73   virtual bool doVetoStep( int , int , int , const Event& ) {return false;}
  74
  75   // Possibility to veto event after parton-level selection.
  76   virtual bool canVetoPartonLevel() {return false;}
  77
  78   // Decide whether to veto current partons or not, based on event record.
  79   // Usage: doVetoPartonLevel( event).
  80   virtual bool doVetoPartonLevel( const Event& ) {return false;}
  81
  82 protected:
  83
  84   // Constructor.
  85   UserHooks() {}
  86
  87   // subEvent extracts currently resolved partons in the hard process.
  88   void subEvent(const Event& event, bool isHardest = true);
  89
  90   // Have one event object around as work area.
  91   Event workEvent;
  92
  93 };
  94
  95 //**************************************************************************
  96
  97 // SuppressSmallPT is a derived class for user access to program execution.
  98 // It is a simple example, illustrating how to suppress the cross section
  99 // of 2 -> 2 processes by a factor pT^4 / (pT0^2 + pT^2)^2, with pT0 input,
 100 // and also modify alpha_strong scale similarly.
 101
 102 class SuppressSmallPT : public UserHooks {
 103
 104 public:
 105
 106   // Constructor.
 107   SuppressSmallPT( double pT0timesMIIn = 1., int numberAlphaSIn = 0,
 108     bool useSameAlphaSasMIIn = true) {isInit = false;
 109     pT0timesMI = pT0timesMIIn; numberAlphaS = numberAlphaSIn;
 110     useSameAlphaSasMI = useSameAlphaSasMIIn;}
 111
 112   // Possibility to modify cross section of process.
 113   virtual bool canModifySigma() {return true;}
 114
 115   // Multiplicative factor modifying the cross section of a hard process.
 116   // Usage: inEvent is true for event generation, false for initialization.
 117   virtual double multiplySigmaBy(const SigmaProcess* sigmaProcessPtr,
 118     const PhaseSpace* phaseSpacePtr, bool );
 119
 120 private:
 121
 122   // Save input properties and the squared pT0 scale.
 123   bool   isInit, useSameAlphaSasMI;
 124   int    numberAlphaS;
 125   double pT0timesMI, pT20;
 126
 127   // Alpha_strong calculation.
 128   AlphaStrong alphaS;
 129
 130 };
 131
 132 //**************************************************************************
 133
 134 // VetoEvolution is a derived class for user access to program execution.
 135 // It is a simple example, to kill events with > nMax partons at scale
 136 // pTcheck in the combined evolution, but only counting partons in the
 137 // hardest interaction and its associated ISR + FSR activity.
 138
 139 class VetoEvolution : public UserHooks {
 140
 141 public:
 142
 143   // Constructor.
 144   VetoEvolution( int nMaxIn, double pTcheckIn) : nMax(nMaxIn),
 145     pTcheck (pTcheckIn){}
 146
 147   // Possibility to veto combined MI + ISR + FSR evolution and
 148   // kill event, e.g. for MLM-style matching of matrix elements.
 149   virtual bool canVetoEvolution() {return true;}
 150
 151   // Transverse-momentum scale for veto test.
 152   virtual double scaleVetoEvolution() {return pTcheck;}
 153
 154   // Decide whether to veto current event or not.
 155   virtual bool doVetoEvolution(const Event& event) {
 156     subEvent( event); return (workEvent.size() > nMax);}
 157
 158 private:
 159
 160   // Saved values from constructor.
 161   int    nMax;
 162   double pTcheck;
 163
 164 };
 165
 166 //**************************************************************************
 167
 168 } // end namespace Pythia8
 169
 170 #endif // Pythia8_UserHooks_H