Matchbox/InsertionOperators/DipoleMIOperator.h

0001 // -*- C++ -*-
0002 //
0003 // DipoleMIOperator.h is a part of Herwig - A multi-purpose Monte Carlo event generator
0004 // Copyright (C) 2002-2019 The Herwig Collaboration
0005 //
0006 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef HERWIG_DipoleMIOperator_H
0010 #define HERWIG_DipoleMIOperator_H
0011 //
0012 // This is the declaration of the DipoleMIOperator class.
0013 //
0014
0015 #include "Herwig/MatrixElement/Matchbox/InsertionOperators/MatchboxInsertionOperator.h"
0016 #include "Herwig/MatrixElement/Matchbox/Base/MatchboxMEBase.h"
0017
0018 namespace Herwig {
0019
0020 using namespace ThePEG;
0021
0022 /**
0023  * \ingroup Matchbox
0024  * \author Simon Platzer, Daniel Rauch, Christian Reuschle,
0025  *         Martin Stoll
0026  *
0027  * \brief DipoleMIOperator implements the I(\epsilon)
0028  * insertion operator for the massive case.
0029  * DipoleMIOperator does only apply for expanded con-
0030  * vention and also not for dimensional reduction.
0031  *
0032  */
0033 class DipoleMIOperator: public MatchboxInsertionOperator {
0034
0035 public:
0036
0037   /** @name Standard constructors and destructors. */
0038   //@{
0039   /**
0040    * The default constructor.
0041    */
0042   DipoleMIOperator();
0043
0044   /**
0045    * The destructor.
0046    */
0047   virtual ~DipoleMIOperator();
0048   //@}
0049
0050 public:
0051
0052   /**
0053    * Set the XComb object steering the Born matrix
0054    * element this class represents virtual corrections to.
0055    */
0056   virtual void setXComb(tStdXCombPtr xc);
0057
0058   /**
0059    * Return true, if this virtual correction
0060    * applies to the given process.
0061    */
0062   virtual bool apply(const cPDVector&) const;
0063
0064   /**
0065    * Return true, if contributions exist to
0066    * the given parton.
0067    */
0068   bool apply(tcPDPtr) const;
0069
0070   /**
0071    * Return a vector of PDG codes of the light flavours,
0072    * which are contained in the jet particle group.
0073    */
0074   vector<int> NLightJetVec() const;
0075
0076   /**
0077    * Return a vector of PDG codes of the heavy flavours,
0078    * which are contained in the jet particle group.
0079    */
0080   vector<int> NHeavyJetVec() const;
0081
0082   /**
0083    * Return a vector of PDG codes of the light flavours,
0084    * which are contained in the associated Born sub-process.
0085    */
0086   vector<int> NLightBornVec() const;
0087
0088   /**
0089    * Return a vector of PDG codes of the heavy flavours,
0090    * which are contained in the associated Born sub-process.
0091    */
0092   vector<int> NHeavyBornVec() const;
0093
0094   /**
0095    * Return a vector of PDG codes of the light flavours,
0096    * which are contained in the proton particle group.
0097    */
0098   vector<int> NLightProtonVec() const;
0099
0100   /**
0101    * Evaluate the finite virtual correction for the
0102    * variables supplied through the Born XComb object
0103    * and possible additional random numbers.
0104    */
0105   virtual double me2() const;
0106
0107   /**
0108    * If defined, return the coefficient of the pole in epsilon^2
0109    */
0110   virtual double oneLoopDoublePole() const;
0111
0112   /**
0113    * If defined, return the coefficient of the pole in epsilon
0114    */
0115   virtual double oneLoopSinglePole() const;
0116
0117 public:
0118
0119   /**
0120    * Triangular / Kallen function
0121    */
0122   template <class T>
0123   inline T rootOfKallen (T a, T b, T c) const {
0124     return sqrt( a*a + b*b + c*c - 2.*( a*b+a*c+b*c ) ); }
0125
0126 public:
0127
0128   /** @name Functions used by the persistent I/O system. */
0129   //@{
0130   /**
0131    * Function used to write out object persistently.
0132    * @param os the persistent output stream written to.
0133    */
0134   void persistentOutput(PersistentOStream & os) const;
0135
0136   /**
0137    * Function used to read in object persistently.
0138    * @param is the persistent input stream read from.
0139    * @param version the version number of the object when written.
0140    */
0141   void persistentInput(PersistentIStream & is, int version);
0142   //@}
0143
0144   /**
0145    * The standard Init function used to initialize the interfaces.
0146    * Called exactly once for each class by the class description system
0147    * before the main function starts or
0148    * when this class is dynamically loaded.
0149    */
0150   static void Init();
0151
0152 protected:
0153
0154   /** @name Clone Methods. */
0155   //@{
0156   /**
0157    * Make a simple clone of this object.
0158    * @return a pointer to the new object.
0159    */
0160   virtual IBPtr clone() const;
0161
0162   /** Make a clone of this object, possibly modifying the cloned object
0163    * to make it sane.
0164    * @return a pointer to the new object.
0165    */
0166   virtual IBPtr fullclone() const;
0167   //@}
0168
0169 private:
0170
0171   /**
0172    * C_A
0173    */
0174   double CA;
0175
0176   /**
0177    * C_F
0178    */
0179   double CF;
0180
0181   /**
0182    * \gamma_q
0183    */
0184   double gammaQuark;
0185
0186   /**
0187    * \gamma_g
0188    */
0189   double gammaGluon;
0190
0191   /**
0192    * \beta_0
0193    * The Matchbox convention is \beta_0=\gamma_g. Often however,
0194    * \beta_0 is defined in the literature as \beta_0=2*\gamma_g.
0195    * Be aware of consistent usage!
0196    * In the massive case (see hep-ph/0011222v3):
0197    *      \beta_0 = 11/3*C_A - 4/3*T_R*(N_f+N_F)
0198    * with T_R=1/2, N_f the number of light flavours ,and N_F the
0199    * number of heavy flavours, which originate in the splittings
0200    * g->qqbar or g->QQbar.
0201    * In our conventions, however:
0202    *      \beta_0 = 11/6*C_A - 2/3*T_R*(N_f+N_F)
0203    * The "massive" \beta_0 applies as soon as we define massive
0204    * flavours in the jet particle group. Be aware that some OLP
0205    * might generically(!) use something like N_f=5 and N_F=1 in
0206    * their definition of \beta_0!
0207    */
0208   double betaZero;
0209
0210   /**
0211    * K_q
0212    */
0213   double KQuark;
0214
0215   /**
0216    * K_g
0217    */
0218   double KGluon;
0219
0220 private:
0221
0222   /**
0223    * V_j, non-singular terms
0224    */
0225   // double Vj(const ParticleData&, const ParticleData&, Energy2, double, bool=false) const;
0226   double Vj(const ParticleData&, const ParticleData&, Energy2, double, double, int, bool=false) const;
0227
0228   /**
0229    * V^{(s)}, double pole part in expanded convention.
0230    */
0231   double VsDoublePole(const ParticleData&, const ParticleData&) const;
0232
0233   /**
0234    * V^{(s)}, single pole part in expanded convention.
0235    */
0236   double VsSinglePole(const ParticleData&, const ParticleData&, Energy2) const;
0237
0238   /**
0239    * \Gamma_q, finite term
0240    */
0241   double GammaQuark(const ParticleData&) const;
0242
0243   /**
0244    * \Gamma_g, finite term
0245    */
0246   double GammaGluon() const;
0247
0248   /**
0249    * \Gamma_q, single pole term
0250    */
0251   double GammaQuarkSinglePole(const ParticleData&) const;
0252
0253   /**
0254    * \Gamma_g, single pole term
0255    */
0256   double GammaGluonSinglePole() const;
0257
0258 private:
0259
0260   /**
0261    * The assignment operator is private and must never be called.
0262    * In fact, it should not even be implemented.
0263    */
0264   DipoleMIOperator & operator=(const DipoleMIOperator &) = delete;
0265
0266 };
0267
0268 }
0269
0270 #endif /* HERWIG_DipoleMIOperator_H */