MatrixElement/Hadron/MEPP2HiggsVBF.h

0001 // -*- C++ -*-
0002 #ifndef HERWIG_MEPP2HiggsVBF_H
0003 #define HERWIG_MEPP2HiggsVBF_H
0004 //
0005 // This is the declaration of the MEPP2HiggsVBF class.
0006 //
0007
0008 #include "Herwig/MatrixElement/MEfftoffH.h"
0009 #include "Herwig/Shower/ShowerAlpha.h"
0010
0011 namespace Herwig {
0012
0013 using namespace ThePEG;
0014
0015 /**
0016  * The MEPP2HiggsVBF class provides the matrix elements for the
0017  * production of the Higgs boson via the vector boson fusion mechanism
0018  * in hadron collisions
0019  *
0020  * @see \ref MEPP2HiggsVBFInterfaces "The interfaces"
0021  * defined for MEPP2HiggsVBF.
0022  */
0023 class MEPP2HiggsVBF: public MEfftoffH {
0024
0025   /**
0026    *  Struct to contain the hadronic system
0027    */
0028   struct tChannelPair{
0029
0030     /**
0031      *  The hadron
0032      */
0033     PPtr hadron;
0034
0035     /**
0036      *  The beam particle data object
0037      */
0038     tcBeamPtr beam;
0039
0040     /**
0041      *  The incoming particle
0042      */
0043     PPtr incoming;
0044
0045     /**
0046      *  The outgoing particle
0047      */
0048     PPtr outgoing;
0049
0050     /**
0051      *  The PDF
0052      */
0053     tcPDFPtr pdf;
0054   };
0055
0056 public:
0057
0058   /**
0059    * The default constructor.
0060    */
0061   MEPP2HiggsVBF();
0062
0063   /** @name Virtual functions required by the MEBase class. */
0064   //@{
0065
0066   /**
0067    * Add all possible diagrams with the add() function.
0068    */
0069   virtual void getDiagrams() const;
0070   //@}
0071
0072   /**
0073    *  Virtual members to be overridden by inheriting classes
0074    *  which implement hard corrections
0075    */
0076   //@{
0077   /**
0078    *  Has a POWHEG style correction
0079    */
0080   virtual POWHEGType hasPOWHEGCorrection() {return Both;}
0081
0082   /**
0083    *  Has an old fashioned ME correction
0084    */
0085   virtual bool hasMECorrection() {return true;}
0086
0087   /**
0088    *  Initialize the ME correction
0089    */
0090   virtual void initializeMECorrection(RealEmissionProcessPtr, double &,
0091                       double & );
0092
0093   /**
0094    *  Apply the hard matrix element correction to a given hard process or decay
0095    */
0096   virtual RealEmissionProcessPtr applyHardMatrixElementCorrection(RealEmissionProcessPtr);
0097
0098   /**
0099    * Apply the soft matrix element correction
0100    * @param parent The initial particle in the current branching
0101    * @param progenitor The progenitor particle of the jet
0102    * @param fs Whether the emission is initial or final-state
0103    * @param highestpT The highest pT so far in the shower
0104    * @param ids ids of the particles produced in the branching
0105    * @param z The momentum fraction of the branching
0106    * @param scale the evolution scale of the branching
0107    * @param pT The transverse momentum of the branching
0108    * @return If true the emission should be vetoed
0109    */
0110   virtual bool softMatrixElementVeto(PPtr parent,
0111                      PPtr progenitor,
0112                      const bool & fs,
0113                      const Energy & highestpT,
0114                      const vector<tcPDPtr> & ids,
0115                      const double & z,
0116                      const Energy & scale,
0117                      const Energy & pT);
0118
0119   /**
0120    *  Apply the POWHEG style correction
0121    */
0122   virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr,
0123                          ShowerInteraction);
0124   //@}
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   /**
0155    *  Generate the hardest emission in the POWHEG approach
0156    */
0157   //@{
0158   /**
0159    *  Generate a Compton process
0160    */
0161   void generateCompton(unsigned int system);
0162
0163   /**
0164    *  Generate a BGF process
0165    */
0166   void generateBGF(unsigned int system);
0167
0168   /**
0169    *  Matrix element piece for the Compton process
0170    */
0171   double comptonME(unsigned int system,
0172            double xT,double xp, double zp, double phi);
0173
0174   /**
0175    *  Matrix element piece for the Compton process
0176    */
0177   double BGFME(unsigned int system,
0178            double xT,double xp, double zp, double phi);
0179
0180   /**
0181    *  Leading order matrix element
0182    */
0183   Energy4 loMatrixElement(const Lorentz5Momentum &p1,
0184               const Lorentz5Momentum &p2,
0185               const Lorentz5Momentum &q1,
0186               const Lorentz5Momentum &q2,
0187               double G1, double G2) const;
0188   //@}
0189
0190   /**
0191    *  Generate the hard emission in the old-fashioned matrix element correction approach
0192    */
0193   //@{
0194   /**
0195    * Generate the values of \f$x_p\f$ and \f$z_p\f$
0196    * @param xp The value of xp, output
0197    * @param zp The value of zp, output
0198    */
0199   double generateComptonPoint(double &xp, double & zp);
0200
0201   /**
0202    * Generate the values of \f$x_p\f$ and \f$z_p\f$
0203    * @param xp The value of xp, output
0204    * @param zp The value of zp, output
0205    */
0206   double generateBGFPoint(double &xp, double & zp);
0207
0208   /**
0209    *  Return the coefficients for the matrix element piece for
0210    *  the QCD compton case. The output is the \f$a_i\f$ coefficients to
0211    *  give the function as
0212    *  \f$a_0+a_1\cos\phi+a_2\sin\phi+a_3\cos^2\phi+a_4\sin^2\phi\f$
0213    * @param xp \f$x_p\f$
0214    * @param x2 \f$x_2\f$
0215    * @param xperp \f$x_\perp\f$
0216    * @param l Scaled momentum of incoming spectator
0217    * @param m Scaled momentum of outgoing spectator
0218    *
0219    */
0220   vector<double> ComptonME(double xp, double x2, double xperp,
0221                LorentzVector<double> l,
0222                LorentzVector<double> m);
0223
0224   /**
0225    *  Return the coefficients for the matrix element piece for
0226    *  the QCD compton case. The output is the \f$a_i\f$ coefficients to
0227    *  give the function as
0228    *  \f$a_0+a_1\cos\phi+a_2\sin\phi+a_3\cos^2\phi+a_4\sin^2\phi\f$
0229    * @param xp \f$x_p\f$
0230    * @param x2 \f$x_3\f$
0231    * @param x3 \f$x_2\f$
0232    * @param xperp \f$x_\perp\f$
0233    * @param l Scaled momentum of incoming spectator
0234    * @param m Scaled momentum of outgoing spectator
0235    *
0236    */
0237   vector<double> BGFME(double xp, double x2, double x3, double xperp,
0238                LorentzVector<double> l,
0239                LorentzVector<double> m);
0240
0241   /**
0242    *  Calculate the coefficient A for the correlations
0243    */
0244   double A(tcPDPtr qin1, tcPDPtr qout1, tcPDPtr qin2, tcPDPtr qout2);
0245   //@}
0246
0247 protected:
0248
0249   /** @name Standard Interfaced functions. */
0250   //@{
0251   /**
0252    * Initialize this object after the setup phase before saving an
0253    * EventGenerator to disk.
0254    * @throws InitException if object could not be initialized properly.
0255    */
0256   virtual void doinit();
0257
0258   /**
0259    * Finalize this object. Called in the run phase just after a
0260    * run has ended. Used eg. to write out statistics.
0261    */
0262   virtual void dofinish();
0263   //@}
0264
0265 protected:
0266
0267   /** @name Clone Methods. */
0268   //@{
0269   /**
0270    * Make a simple clone of this object.
0271    * @return a pointer to the new object.
0272    */
0273   virtual IBPtr clone() const { return new_ptr(*this); }
0274
0275   /** Make a clone of this object, possibly modifying the cloned object
0276    * to make it sane.
0277    * @return a pointer to the new object.
0278    */
0279   virtual IBPtr fullclone() const { return new_ptr(*this); }
0280   //@}
0281
0282 private:
0283
0284   /**
0285    * The assignment operator is private and must never be called.
0286    * In fact, it should not even be implemented.
0287    */
0288   MEPP2HiggsVBF & operator=(const MEPP2HiggsVBF &) = delete;
0289
0290 private:
0291
0292   /**
0293    *  Parameters for the hard POWHEG emission
0294    */
0295   //@{
0296   /**
0297    *  Pointer to the object calculating the strong coupling
0298    */
0299   ShowerAlphaPtr alpha_;
0300
0301   /**
0302    *  Weight for the compton channel
0303    */
0304   double comptonWeight_;
0305
0306   /**
0307    *  Weight for the BGF channel
0308    */
0309   double BGFWeight_;
0310
0311   /**
0312    *  Minimum value of \f$p_T\f$
0313    */
0314   Energy pTmin_;
0315
0316   /**
0317    *  Gluon particle data object
0318    */
0319   PDPtr gluon_;
0320   //@}
0321
0322   /**
0323    *  Properties of the emission
0324    */
0325   //@{
0326   /**
0327    *  Beam particle
0328    */
0329   tcBeamPtr beam_[2];
0330
0331   /**
0332    *  PDF object
0333    */
0334   tcPDFPtr pdf_[2];
0335
0336   /**
0337    *  Partons
0338    */
0339   tcPDPtr partons_[2][4];
0340
0341   /**
0342    *  q
0343    */
0344   Lorentz5Momentum q_[2];
0345
0346   /**
0347    *  \f$Q^2\f$
0348    */
0349   Energy2 q2_[2];
0350
0351   /**
0352    *  Coupling factor
0353    */
0354   double acoeff_;
0355
0356   /**
0357    *  Lorentz vectors for the matrix element
0358    */
0359   LorentzVector<double> l_;
0360
0361   /**
0362    *  Lorentz vectors for the matrix element
0363    */
0364   LorentzVector<double> m_;
0365
0366   /**
0367    *  Born momentum fraction
0368    */
0369   double xB_[2];
0370
0371   /**
0372    *  Rotation to the Breit frame
0373    */
0374   LorentzRotation rot_[2];
0375
0376   /**
0377    *  Quark momenta for spectator system
0378    */
0379   Lorentz5Momentum pother_[2][2];
0380
0381   /**
0382    *  Quark momenta for emitting system
0383    */
0384   Lorentz5Momentum psystem_[2][2];
0385
0386   /**
0387    *  Higgs momenta
0388    */
0389   Lorentz5Momentum phiggs_[2];
0390
0391   /**
0392    *  Transverse momenta for the compton emissions
0393    */
0394   Energy pTCompton_[2];
0395
0396   /**
0397    *  Transverse momenta for the BGF emissions
0398    */
0399   Energy pTBGF_[2];
0400
0401   /**
0402    *  Whether the Compton radiation is ISR or FSR
0403    */
0404   bool ComptonISFS_[2];
0405
0406   /**
0407    *  Momenta of the particles for a compton emission
0408    */
0409   vector<Lorentz5Momentum> ComptonMomenta_[2];
0410
0411   /**
0412    *  Momenta of the particles for a BGF emission
0413    */
0414   vector<Lorentz5Momentum> BGFMomenta_[2];
0415
0416   /**
0417    *  the systems
0418    */
0419   vector<tChannelPair> systems_;
0420
0421   /**
0422    *  Higgs boson
0423    */
0424   PPtr higgs_;
0425   //@}
0426
0427   /**
0428    *  Parameters for the matrix element correction
0429    */
0430   //@{
0431   /**
0432    *  Enchancement factor for ISR
0433    */
0434   double initial_;
0435
0436   /**
0437    *  Enchancement factor for FSR
0438    */
0439   double final_;
0440
0441   /**
0442    *   Relative fraction of compton and BGF processes to generate
0443    */
0444   double procProb_;
0445
0446   /**
0447    *  Integral for compton process
0448    */
0449   double comptonInt_;
0450
0451   /**
0452    *  Integral for BGF process
0453    */
0454   double bgfInt_;
0455
0456   /**
0457    *  Number of weights greater than 1
0458    */
0459   unsigned int nover_;
0460
0461   /**
0462    *  Maximum weight
0463    */
0464   pair<double,double> maxwgt_;
0465   //@}
0466
0467 };
0468
0469 }
0470
0471 #endif /* HERWIG_MEPP2HiggsVBF_H */