Herwig/PDF/PomeronFlux.h

0001 // -*- C++ -*-
0002 #ifndef Herwig_PomeronFlux_H
0003 #define Herwig_PomeronFlux_H
0004 //
0005 // This is the declaration of the PomeronFlux class.
0006 //
0007
0008 #include "ThePEG/PDF/PDFBase.h"
0009
0010 namespace Herwig {
0011
0012 using namespace ThePEG;
0013
0014 /**
0015  * Here is the documentation of the PomeronFlux class.
0016  *
0017  * @see \ref PomeronFluxInterfaces "The interfaces"
0018  * defined for PomeronFlux.
0019  */
0020 class PomeronFlux: public PDFBase {
0021
0022 public:
0023
0024   /**
0025    *  Default constructor
0026    */
0027   PomeronFlux();
0028
0029   /** @name Virtual functions to be overridden by sub-classes. */
0030   //@{
0031   /**
0032    * Return true if this PDF can handle the extraction of partons from
0033    * the given \a particle.
0034    */
0035   virtual bool canHandleParticle(tcPDPtr particle) const;
0036
0037   /**
0038    * Return the partons which this PDF may extract from the given
0039    * \a particle.
0040    */
0041   virtual cPDVector partons(tcPDPtr particle) const;
0042
0043   /**
0044    * The density. Return the pdf for the given \a parton inside the
0045    * given \a particle for the virtuality \a partonScale and
0046    * logarithmic momentum fraction \a l \f$(l=\log(1/x)\f$. The \a
0047    * particle is assumed to have a virtuality \a particleScale.
0048    */
0049   virtual double xfl(tcPDPtr particle, tcPDPtr parton, Energy2 partonScale,
0050              double l, Energy2 particleScale = ZERO) const;
0051
0052   /**
0053    * The valence density. Return the pdf for the given cvalence \a
0054    * parton inside the given \a particle for the virtuality \a
0055    * partonScale and logarithmic momentum fraction \a l
0056    * \f$(l=\log(1/x)\f$. The \a particle is assumed to have a
0057    * virtuality \a particleScale. If not overidden by a sub class this
0058    * will return zero.
0059    */
0060   virtual double xfvl(tcPDPtr particle, tcPDPtr parton, Energy2 partonScale,
0061              double l, Energy2 particleScale = ZERO) const;
0062
0063   /**
0064    * Generate scale (as a fraction of the maximum scale). If the PDF
0065    * contains strange peaks which can be difficult to handle, this
0066    * function may be overwritten to return an appropriate scale
0067    * \f$Q^2/Q^2_{\max}\f$ for a \a z uniformly distributed in
0068    * ]0,1[. Also the jacobobian of the \f$Q^2/Q^2_{\max}\rightarrow
0069    * z\f$ variable transformation must multiply the \a jacobian
0070    * argument. The default version will simply use the function
0071    * \f$Q^2/Q^2_{\max} = (Q^2_{\max}/Q^2_{\min})^(z-1)\f$ or, if
0072    * \f$Q^2_{\min}\f$ is zero, \f$Q^2/Q^2_{\max} = z\f$ (where the
0073    * limits are set by \a cut).
0074    */
0075   virtual double flattenScale(tcPDPtr particle, tcPDPtr parton,
0076                    const PDFCuts & cut, double l, double z,
0077                    double & jacobian) const;
0078
0079
0080   /**
0081    * Generate a momentum fraction. If the PDF contains strange peaks
0082    * which can be difficult to handle, this function may be
0083    * overwritten to return an appropriate \f$l=\log(1/x)\f$ for a \a z
0084    * uniformly distributed in ]0,1[. Also the jacobobian of the
0085    * \f$l\rightarrow z\f$ variable transformation must in the function
0086    * multiply the \a jacobian argument. The default version will
0087    * simply use the function \f$l(z) = l_{\min} +
0088    * z*(l_{\max}-l_{\min})\f$ (where the limits are set by \a cut).
0089    */
0090   virtual double flattenL(tcPDPtr particle, tcPDPtr parton, const PDFCuts &cut,
0091               double z, double & jacobian) const;
0092   //@}
0093
0094 public:
0095
0096   /** @name Functions used by the persistent I/O system. */
0097   //@{
0098   /**
0099    * Function used to write out object persistently.
0100    * @param os the persistent output stream written to.
0101    */
0102   void persistentOutput(PersistentOStream & os) const;
0103
0104   /**
0105    * Function used to read in object persistently.
0106    * @param is the persistent input stream read from.
0107    * @param version the version number of the object when written.
0108    */
0109   void persistentInput(PersistentIStream & is, int version);
0110   //@}
0111
0112   /**
0113    * The standard Init function used to initialize the interfaces.
0114    * Called exactly once for each class by the class description system
0115    * before the main function starts or
0116    * when this class is dynamically loaded.
0117    */
0118   static void Init();
0119
0120   /**
0121    * Set normalization constant Ap of the pomeron flux.
0122    */
0123    virtual void doinit();
0124
0125 protected:
0126
0127   /** @name Clone Methods. */
0128   //@{
0129   /**
0130    * Make a simple clone of this object.
0131    * @return a pointer to the new object.
0132    */
0133   virtual IBPtr clone() const {return new_ptr(*this);}
0134
0135   /** Make a clone of this object, possibly modifying the cloned object
0136    * to make it sane.
0137    * @return a pointer to the new object.
0138    */
0139   virtual IBPtr fullclone() const {return new_ptr(*this);}
0140   //@}
0141
0142 private:
0143
0144   /**
0145    * The assignment operator is private and must never be called.
0146    * In fact, it should not even be implemented.
0147    */
0148   PomeronFlux & operator=(const PomeronFlux &) = delete;
0149
0150 private:
0151
0152   /**
0153    *  Integrated pomeron/regeon flux over qq in the range qqmin ... qqmax
0154    *  (with normalization constant Ap = 1 GeV2).
0155    *  The flux normalization constant is obtained \f$x_p*intFx_p = 1\f$,
0156    *  where x_p = 0.003.
0157    */
0158   Energy2 intxFx(double x, Energy2 qqmin, Energy2 qqmax,
0159          double alfa0, InvEnergy2 alfap,  InvEnergy2 beta) const;
0160
0161   /**
0162    * Helper function in doinit() which sets the parameters of the
0163    * pomeron/regeon flux according to user setup.
0164    */
0165   void setFluxPar();
0166
0167
0168 private:
0169
0170   /**
0171    *  Minimum \f$Q^2\f$ for the pomeron/reggeon
0172    */
0173   Energy2 q2min_;
0174
0175   /**
0176    *  Maximum \f$Q^2\f$ for the pomeron/reggeon
0177    */
0178   Energy2 q2max_;
0179
0180   /**
0181    * Cut on the minimum xi
0182    */
0183   double xiMin_;
0184
0185   /**
0186    * Cut on the maximum xi
0187    */
0188   double xiMax_;
0189
0190   /**
0191    * Pomeron intercept
0192    */
0193   double alfa0P_;
0194
0195   /**
0196    *  Pomeron slope
0197    */
0198   InvEnergy2 alfapP_;
0199
0200   /**
0201    * Parameter of pomeron flux Bp
0202    */
0203   InvEnergy2 betaP_;
0204
0205   /**
0206    * Normalization constant of the pomeron flux
0207    */
0208   InvEnergy2 normP_;
0209
0210   /**
0211    * Reggeon intercept
0212    */
0213   double alfa0R_;
0214
0215   /**
0216    *  Reggeon slope
0217    */
0218   InvEnergy2 alfapR_;
0219
0220   /**
0221    * Parameter of reggeon flux Bp
0222    */
0223   InvEnergy2 betaR_;
0224
0225   /**
0226    * Normalization constant of the reggeon flux
0227    */
0228   InvEnergy2 normR_;
0229
0230   /**
0231    * Factor of the pomeron flux
0232    */
0233   double nR_;
0234
0235   /**
0236    * Switch between pomeron/regeon structure function fits.
0237    * The flux parameters are set according to the fit choice.
0238    */
0239   int PDFFit_;
0240
0241 };
0242
0243 }
0244
0245 #endif /* Herwig_PomeronFlux_H */