MatrixElement/Hadron/MEPP2GammaJet.h

0001 // -*- C++ -*-
0002 //
0003 // MEPP2GammaJet.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_MEPP2GammaJet_H
0010 #define HERWIG_MEPP2GammaJet_H
0011 //
0012 // This is the declaration of the MEPP2GammaJet class.
0013 //
0014
0015 #include "Herwig/MatrixElement/HwMEBase.h"
0016 #include "ThePEG/Helicity/Vertex/AbstractFFVVertex.h"
0017 #include "Herwig/MatrixElement/ProductionMatrixElement.h"
0018 #include "ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h"
0019 #include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h"
0020 #include "ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h"
0021
0022 namespace Herwig {
0023
0024 using namespace ThePEG;
0025 using namespace ThePEG::Helicity;
0026
0027 /** \ingroup MatrixElements
0028  * The MEPP2GammaJet class implements the matrix element for photon+jet
0029  * production in hadron-hadron collisions.
0030  *
0031  * @see \ref MEPP2GammaJetInterfaces "The interfaces"
0032  * defined for MEPP2GammaJet.
0033  */
0034 class MEPP2GammaJet: public HwMEBase {
0035
0036 public:
0037
0038   /**
0039    * The default constructor.
0040    */
0041   MEPP2GammaJet();
0042
0043   /** @name Virtual functions required by the MEBase class. */
0044   //@{
0045   /**
0046    * Return the order in \f$\alpha_S\f$ in which this matrix
0047    * element is given.
0048    */
0049   virtual unsigned int orderInAlphaS() const;
0050
0051   /**
0052    * Return the order in \f$\alpha_{EW}\f$ in which this matrix
0053    * element is given.
0054    */
0055   virtual unsigned int orderInAlphaEW() const;
0056
0057   /**
0058    * The matrix element for the kinematical configuration
0059    * previously provided by the last call to setKinematics(), suitably
0060    * scaled by sHat() to give a dimension-less number.
0061    * @return the matrix element scaled with sHat() to give a
0062    * dimensionless number.
0063    */
0064   virtual double me2() const;
0065
0066   /**
0067    * Return the scale associated with the last set phase space point.
0068    */
0069   virtual Energy2 scale() const;
0070
0071   /**
0072    * Add all possible diagrams with the add() function.
0073    */
0074   virtual void getDiagrams() const;
0075
0076   /**
0077    * Get diagram selector. With the information previously supplied with the
0078    * setKinematics method, a derived class may optionally
0079    * override this method to weight the given diagrams with their
0080    * (although certainly not physical) relative probabilities.
0081    * @param dv the diagrams to be weighted.
0082    * @return a Selector relating the given diagrams to their weights.
0083    */
0084   virtual Selector<DiagramIndex> diagrams(const DiagramVector & dv) const;
0085
0086   /**
0087    * Return a Selector with possible colour geometries for the selected
0088    * diagram weighted by their relative probabilities.
0089    * @param diag the diagram chosen.
0090    * @return the possible colour geometries weighted by their
0091    * relative probabilities.
0092    */
0093   virtual Selector<const ColourLines *>
0094   colourGeometries(tcDiagPtr diag) const;
0095
0096   /**
0097    *  Construct the vertex of spin correlations.
0098    */
0099   virtual void constructVertex(tSubProPtr);
0100   //@}
0101
0102
0103 public:
0104
0105   /** @name Functions used by the persistent I/O system. */
0106   //@{
0107   /**
0108    * Function used to write out object persistently.
0109    * @param os the persistent output stream written to.
0110    */
0111   void persistentOutput(PersistentOStream & os) const;
0112
0113   /**
0114    * Function used to read in object persistently.
0115    * @param is the persistent input stream read from.
0116    * @param version the version number of the object when written.
0117    */
0118   void persistentInput(PersistentIStream & is, int version);
0119   //@}
0120
0121   /**
0122    * The standard Init function used to initialize the interfaces.
0123    * Called exactly once for each class by the class description system
0124    * before the main function starts or
0125    * when this class is dynamically loaded.
0126    */
0127   static void Init();
0128
0129 protected:
0130
0131   /** @name Clone Methods. */
0132   //@{
0133   /**
0134    * Make a simple clone of this object.
0135    * @return a pointer to the new object.
0136    */
0137   virtual IBPtr clone() const { return new_ptr(*this); }
0138
0139   /** Make a clone of this object, possibly modifying the cloned object
0140    * to make it sane.
0141    * @return a pointer to the new object.
0142    */
0143   virtual IBPtr fullclone() const { return new_ptr(*this); }
0144   //@}
0145
0146 protected:
0147
0148   /** @name Standard Interfaced functions. */
0149   //@{
0150   /**
0151    * Initialize this object after the setup phase before saving an
0152    * EventGenerator to disk.
0153    * @throws InitException if object could not be initialized properly.
0154    */
0155   virtual void doinit();
0156
0157   /**
0158    * Rebind pointer to other Interfaced objects. Called in the setup phase
0159    * after all objects used in an EventGenerator has been cloned so that
0160    * the pointers will refer to the cloned objects afterwards.
0161    * @param trans a TranslationMap relating the original objects to
0162    * their respective clones.
0163    * @throws RebindException if no cloned object was found for a given
0164    * pointer.
0165    */
0166   virtual void rebind(const TranslationMap & trans)
0167    ;
0168
0169   /**
0170    * Return a vector of all pointers to Interfaced objects used in this
0171    * object.
0172    * @return a vector of pointers.
0173    */
0174   virtual IVector getReferences();
0175   //@}
0176
0177 private:
0178
0179   /**
0180    *  Members to return the matrix elements for the different subprocesses
0181    */
0182   //@{
0183   /**
0184    * Matrix element for \f$q\bar{q}\to g\gamma\f$.
0185    * @param fin   Spinors for incoming quark
0186    * @param ain   Spinors for incoming antiquark
0187    * @param gout  Polarization vectors for the outgoing gluon
0188    * @param pout  Polarization vectors for the outgoing photon
0189    * @param me    Whether or not to calculate the matrix element for spin correlations
0190    */
0191   double qqbarME(vector<SpinorWaveFunction> & fin, vector<SpinorBarWaveFunction> & ain,
0192          vector<VectorWaveFunction> & gout, vector<VectorWaveFunction>    & pout,
0193          bool me) const;
0194
0195   /**
0196    * Matrix element for \f$qg\to \gamma q\f$.
0197    * @param fin   Spinors for incoming quark
0198    * @param gin   Polarization vectors for the incoming gluon
0199    * @param pout  Polarization vectors for the outgoing photon
0200    * @param fout  Spinors for outgoing quark
0201    * @param me    Whether or not to calculate the matrix element for spin correlations
0202    */
0203   double qgME(vector<SpinorWaveFunction> & fin,vector<VectorWaveFunction>     & gin,
0204           vector<VectorWaveFunction> & pout,vector<SpinorBarWaveFunction> & fout,
0205           bool me) const;
0206
0207   /**
0208    * Matrix element for \f$\bar{q}g\to \gamma \bar{q}\f$.
0209    * @param ain   Spinors for the incoming antiquark
0210    * @param gin   Polarization vectors for the incoming gluon
0211    * @param pout  Polarization vectors for the outgoing photon
0212    * @param aout  Spinors for the outgoing antiquark
0213    * @param me    Whether or not to calculate the matrix element for spin correlations
0214    */
0215   double qbargME(vector<SpinorBarWaveFunction> & ain, vector<VectorWaveFunction> & gin,
0216          vector<VectorWaveFunction> & pout, vector<SpinorWaveFunction> & aout,
0217          bool me) const;
0218   //@}
0219
0220 private:
0221
0222   /**
0223    * The assignment operator is private and must never be called.
0224    * In fact, it should not even be implemented.
0225    */
0226   MEPP2GammaJet & operator=(const MEPP2GammaJet &) = delete;
0227
0228 private:
0229
0230   /**
0231    *  Pointer to the quark-antiquark-gluon vertex
0232    */
0233   AbstractFFVVertexPtr _gluonvertex;
0234
0235   /**
0236    *  Pointer to the quark-antiquark-photon vertex
0237    */
0238   AbstractFFVVertexPtr _photonvertex;
0239
0240   /**
0241    *  Maximum PDG code of the quarks allowed
0242    */
0243   int _maxflavour;
0244
0245   /**
0246    *  Option for which processes to include
0247    */
0248   unsigned int _processopt;
0249
0250   /**
0251    * Matrix element for spin correlations
0252    */
0253   ProductionMatrixElement _me;
0254
0255   /**
0256    *  Scale prefactor
0257    */
0258   double scalePreFactor_;
0259 };
0260
0261 }
0262
0263 #endif /* HERWIG_MEPP2GammaJet_H */