diff --git a/Decay/Perturbative/SMHiggsFermionsPOWHEGDecayer.h b/Decay/Perturbative/SMHiggsFermionsPOWHEGDecayer.h --- a/Decay/Perturbative/SMHiggsFermionsPOWHEGDecayer.h +++ b/Decay/Perturbative/SMHiggsFermionsPOWHEGDecayer.h @@ -1,272 +1,272 @@ // -*- C++ -*- #ifndef HERWIG_SMHiggsFermionsPOWHEGDecayer_H #define HERWIG_SMHiggsFermionsPOWHEGDecayer_H // // This is the declaration of the SMHiggsFermionsPOWHEGDecayer class. // #include "SMHiggsFermionsDecayer.h" #include "Herwig/Utilities/Maths.h" #include "Herwig/Shower/Core/Couplings/ShowerAlpha.fh" namespace Herwig { using namespace ThePEG; /** * Here is the documentation of the SMHiggsFermionsPOWHEGDecayer class. * * @see \ref SMHiggsFermionsPOWHEGDecayerInterfaces "The interfaces" * defined for SMHiggsFermionsPOWHEGDecayer. */ class SMHiggsFermionsPOWHEGDecayer: public SMHiggsFermionsDecayer { public: /** * The default constructor. */ SMHiggsFermionsPOWHEGDecayer(); /** * Virtual members to be overridden by inheriting classes * which implement hard corrections */ //@{ /** * Has a POWHEG style correction */ virtual POWHEGType hasPOWHEGCorrection() {return FSR;} /** * Apply the POWHEG style correction */ virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr); //@} virtual double me2(const int ichan, const Particle & part, const ParticleVector & decay, MEOption meopt) const; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initSMHiggsFermionsPOWHEGDecayer; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SMHiggsFermionsPOWHEGDecayer & operator=(const SMHiggsFermionsPOWHEGDecayer &); + SMHiggsFermionsPOWHEGDecayer & operator=(const SMHiggsFermionsPOWHEGDecayer &) = delete; /** * Calcluate the Kallen function */ double calculateLambda(double x, double y, double z) const; /** * Dipole subtraction term */ InvEnergy2 dipoleSubtractionTerm(double x1, double x2) const; /** * Real emission term */ InvEnergy2 calculateRealEmission(double x1, double x2) const; /** * Virtual term */ double calculateVirtualTerm() const; /** * Non-singlet term */ double calculateNonSingletTerm(double beta, double L) const; /** * Check the sign of the momentum in the \f$z\f$-direction is correct. */ bool checkZMomenta(double x1, double x2, double x3, double y, Energy pT) const; /** * Calculate the Jacobian */ InvEnergy calculateJacobian(double x1, double x2, Energy pT) const; /** * Generate a real emission event */ bool getEvent(); private: /** * The colour factor */ double CF_; /** * The Higgs mass */ mutable Energy mHiggs_; /** * The reduced mass */ mutable double mu_; /** * The square of the reduced mass */ mutable double mu2_; /** * The strong coupling */ mutable double aS_; /** * Stuff ofr the POWHEG correction */ //@{ /** * Pointer to the object calculating the strong coupling */ ShowerAlphaPtr alphaS_; /** * ParticleData object for the gluon */ tcPDPtr gluon_; /** * The cut off on pt, assuming massless quarks. */ Energy pTmin_; // radiative variables (pt,y) Energy pT_; /** * The ParticleData objects for the fermions */ vector partons_; /** * The fermion momenta */ vector quark_; /** * The momentum of the radiated gauge boson */ Lorentz5Momentum gauge_; /** * The Higgs boson */ PPtr higgs_; /** * Higgs mass squared */ Energy2 mh2_; //@} }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of SMHiggsFermionsPOWHEGDecayer. */ template <> struct BaseClassTrait { /** Typedef of the first base class of SMHiggsFermionsPOWHEGDecayer. */ typedef Herwig::SMHiggsFermionsDecayer NthBase; }; /** This template specialization informs ThePEG about the name of * the SMHiggsFermionsPOWHEGDecayer class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Herwig::SMHiggsFermionsPOWHEGDecayer"; } /** * The name of a file containing the dynamic library where the class * SMHiggsFermionsPOWHEGDecayer is implemented. It may also include several, space-separated, * libraries if the class SMHiggsFermionsPOWHEGDecayer depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "HwPerturbativeHiggsDecay.so"; } }; /** @endcond */ } #endif /* HERWIG_SMHiggsFermionsPOWHEGDecayer_H */ diff --git a/Decay/Perturbative/SMTopPOWHEGDecayer.h b/Decay/Perturbative/SMTopPOWHEGDecayer.h --- a/Decay/Perturbative/SMTopPOWHEGDecayer.h +++ b/Decay/Perturbative/SMTopPOWHEGDecayer.h @@ -1,166 +1,166 @@ // -*- C++ -*- #ifndef Herwig_SMTopPOWHEGDecayer_H #define Herwig_SMTopPOWHEGDecayer_H // // This is the declaration of the SMTopPOWHEGDecayer class. // #include "SMTopDecayer.h" namespace Herwig { using namespace ThePEG; /** * Here is the documentation of the SMTopPOWHEGDecayer class. * * @see \ref SMTopPOWHEGDecayerInterfaces "The interfaces" * defined for SMTopPOWHEGDecayer. */ class SMTopPOWHEGDecayer: public SMTopDecayer { public: /** * The default constructor. */ SMTopPOWHEGDecayer(); /** * Has a POWHEG style correction */ virtual POWHEGType hasPOWHEGCorrection() {return FSR;} /** * Apply the POWHEG style correction */ virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr); /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} protected: /** * check if event is in dead region */ bool deadZoneCheck(double xw, double xg); protected: /** * Calculate matrix element ratio B/R */ double matrixElementRatio(vector particleMomenta); protected: /** * Calculate momenta of t, b, W, g */ bool calcMomenta(int j, Energy pT, double y, double phi, double& xg, double& xw, double& xb, double& xb_z, vector& particleMomenta); protected: /** * Check the calculated momenta are physical */ bool psCheck(double xg, double xw); protected: /** * Return the momenta including the hard emission */ vector hardMomenta(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SMTopPOWHEGDecayer & operator=(const SMTopPOWHEGDecayer &); + SMTopPOWHEGDecayer & operator=(const SMTopPOWHEGDecayer &) = delete; private: /** * Top quark mass */ Energy mt_; /** * Reduced \f$W^\pm\f$ mass */ double w_; /** * Reduced bottom mass */ double b_; /** * Reduced \f$W^\pm\f$ mass squared */ double w2_; /** * Reduced bottom mass squared */ double b2_; /** * Minimum \f$p_T\f$ */ Energy pTmin_; /** * Transverse momentum of the emission */ Energy pT_; }; } #endif /* Herwig_SMTopPOWHEGDecayer_H */ diff --git a/Decay/Perturbative/SMWFermionsPOWHEGDecayer.h b/Decay/Perturbative/SMWFermionsPOWHEGDecayer.h --- a/Decay/Perturbative/SMWFermionsPOWHEGDecayer.h +++ b/Decay/Perturbative/SMWFermionsPOWHEGDecayer.h @@ -1,309 +1,309 @@ // -*- C++ -*- #ifndef HERWIG_SMWFermionsPOWHEGDecayer_H #define HERWIG_SMWFermionsPOWHEGDecayer_H // // This is the declaration of the SMWFermionsPOWHEGDecayer class. // #include "SMWDecayer.h" #include "Herwig/Utilities/Maths.h" namespace Herwig { using namespace ThePEG; /** * Here is the documentation of the SMWFermionsPOWHEGDecayer class. * * @see \ref SMWFermionsPOWHEGDecayerInterfaces "The interfaces" * defined for SMWFermionsPOWHEGDecayer. */ class SMWFermionsPOWHEGDecayer: public SMWDecayer { public: /** * The default constructor. */ SMWFermionsPOWHEGDecayer(); /** * Virtual members to be overridden by inheriting classes * which implement hard corrections */ //@{ /** * Has a POWHEG style correction */ virtual POWHEGType hasPOWHEGCorrection() {return FSR;} /** * Apply the POWHEG style correction */ virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr); //@} virtual double me2(const int ichan, const Particle & part, const ParticleVector & decay, MEOption meopt) const; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initSMWFermionsPOWHEGDecayer; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SMWFermionsPOWHEGDecayer & operator=(const SMWFermionsPOWHEGDecayer &); + SMWFermionsPOWHEGDecayer & operator=(const SMWFermionsPOWHEGDecayer &) = delete; /** * Pointer to the fermion-antifermion W vertex */ AbstractFFVVertexPtr FFWVertex() const {return FFWVertex_;} /** * Pointer to the fermion-antifermion G vertex */ AbstractFFVVertexPtr FFGVertex() const {return FFGVertex_;} /** * Real emission term, for use in generating the hardest emission */ double calculateRealEmission(double x1, double x2, vector hardProcess, double phi, double muj, double muk, int iemit, bool subtract) const; /** * Check the sign of the momentum in the \f$z\f$-direction is correct. */ bool checkZMomenta(double x1, double x2, double x3, double y, Energy pT, double muj, double muk) const; /** * Calculate the Jacobian */ InvEnergy calculateJacobian(double x1, double x2, Energy pT, double muj, double muk) const; /** * Calculate the ratio between NLO & LO ME */ double meRatio(vector partons, vector momenta, unsigned int iemitter,bool subtract) const; /** * Calculate the LO ME */ double loME(const vector & partons, const vector & momenta) const; /** * Calculate the NLO real emission piece of ME */ InvEnergy2 realME(const vector & partons, const vector & momenta) const; /** * Generate a real emission event */ bool getEvent(vector hardProcess); private: /** * Pointer to the fermion-antifermion W vertex */ AbstractFFVVertexPtr FFWVertex_; /** * Pointer to the fermion-antifermion G vertex */ AbstractFFVVertexPtr FFGVertex_; /** * The colour factor */ double CF_; /** * The W mass */ mutable Energy mW_; // TODO: delete this mutable double mu_; /** * The reduced mass of particle 1 */ mutable double mu1_; /** * The reduced mass of particle 1 squared */ mutable double mu12_; /** * The reduceed mass of particle 2 */ mutable double mu2_; /** * The reduceed mass of particle 2 squared */ mutable double mu22_; /** * The strong coupling */ mutable double aS_; /** * The scale */ mutable Energy2 scale_; /** * Stuff for the POWHEG correction */ //@{ /** * ParticleData object for the gluon */ tcPDPtr gluon_; /** * The cut off on pt, assuming massless quarks. */ Energy pTmin_; // radiative variables (pt,y) Energy pT_; /** * The ParticleData objects for the fermions */ vector partons_; /** * The fermion momenta */ vector quark_; /** * The momentum of the radiated gauge boson */ Lorentz5Momentum gauge_; /** * The W boson */ PPtr wboson_; /** * W mass squared */ Energy2 mw2_; //@} }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of SMWFermionsPOWHEGDecayer. */ template <> struct BaseClassTrait { /** Typedef of the first base class of SMWFermionsPOWHEGDecayer. */ typedef Herwig::SMWDecayer NthBase; }; /** This template specialization informs ThePEG about the name of * the SMWFermionsPOWHEGDecayer class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Herwig::SMWFermionsPOWHEGDecayer"; } /** * The name of a file containing the dynamic library where the class * SMWFermionsPOWHEGDecayer is implemented. It may also include several, space-separated, * libraries if the class SMWFermionsPOWHEGDecayer depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "HwPerturbativeDecay.so"; } }; /** @endcond */ } #endif /* HERWIG_SMWFermionsPOWHEGDecayer_H */ diff --git a/Decay/Perturbative/SMZFermionsPOWHEGDecayer.h b/Decay/Perturbative/SMZFermionsPOWHEGDecayer.h --- a/Decay/Perturbative/SMZFermionsPOWHEGDecayer.h +++ b/Decay/Perturbative/SMZFermionsPOWHEGDecayer.h @@ -1,300 +1,300 @@ // -*- C++ -*- #ifndef HERWIG_SMZFermionsPOWHEGDecayer_H #define HERWIG_SMZFermionsPOWHEGDecayer_H // // This is the declaration of the SMZFermionsPOWHEGDecayer class. // #include "SMZDecayer.h" #include "Herwig/Utilities/Maths.h" namespace Herwig { using namespace ThePEG; /** * Here is the documentation of the SMZFermionsPOWHEGDecayer class. * * @see \ref SMZFermionsPOWHEGDecayerInterfaces "The interfaces" * defined for SMZFermionsPOWHEGDecayer. */ class SMZFermionsPOWHEGDecayer: public SMZDecayer{ public: /** * The default constructor. */ SMZFermionsPOWHEGDecayer(); /** * Has a POWHEG style correction */ virtual POWHEGType hasPOWHEGCorrection() {return FSR;} /** * Apply the POWHEG style correction */ virtual RealEmissionProcessPtr generateHardest(RealEmissionProcessPtr); /** * Virtual members to be overridden by inheriting classes * which implement hard corrections */ virtual double me2(const int ichan, const Particle & part, const ParticleVector & decay, MEOption meopt) const; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initSMZFermionsPOWHEGDecayer; /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SMZFermionsPOWHEGDecayer & operator=(const SMZFermionsPOWHEGDecayer &); + SMZFermionsPOWHEGDecayer & operator=(const SMZFermionsPOWHEGDecayer &) = delete; /** * Pointer to the fermion-antifermion Z vertex */ AbstractFFVVertexPtr FFZVertex() const {return FFZVertex_;} /** * Pointer to the fermion-antifermion Z vertex */ AbstractFFVVertexPtr FFGVertex() const {return FFGVertex_;} /** * Real emission term, for use in generating the hardest emission */ double calculateRealEmission(double x1, double x2, vector hardProcess, double phi, bool subtract, int emitter) const; /** * Real emission term, for use in generating the hardest emission */ double calculateRealEmission(double x1, double x2, vector hardProcess, double phi, bool subtract) const; /** * Check the sign of the momentum in the \f$z\f$-direction is correct. */ bool checkZMomenta(double x1, double x2, double x3, double y, Energy pT) const; /** * Calculate the Jacobian */ InvEnergy calculateJacobian(double x1, double x2, Energy pT) const; /** * Calculate the ratio between NLO & LO ME */ double meRatio(vector partons, vector momenta, unsigned int iemitter,bool subtract) const; /** * Calculate the LO ME */ double loME(const vector & partons, const vector & momenta) const; /** * Calculate the NLO real emission piece of ME */ InvEnergy2 realME(const vector & partons, const vector & momenta) const; /** * Generate a real emission event */ bool getEvent(vector hardProcess); private: /** * Pointer to the fermion-antifermion Z vertex */ AbstractFFVVertexPtr FFZVertex_; /** * Pointer to the fermion-antifermion G vertex */ AbstractFFVVertexPtr FFGVertex_; /** * The colour factor */ double CF_; /** * The Z mass */ mutable Energy mZ_; /** * The reduced mass */ mutable double mu_; /** * The square of the reduced mass */ mutable double mu2_; /** * The strong coupling */ mutable double aS_; /** * The scale */ mutable Energy2 scale_; /** * Stuff for the POWHEG correction */ //@{ /** * ParticleData object for the gluon */ tcPDPtr gluon_; /** * The cut off on pt, assuming massless quarks. */ Energy pTmin_; // radiative variables (pt,y) Energy pT_; /** * The ParticleData objects for the fermions */ vector partons_; /** * The fermion momenta */ vector quark_; /** * The momentum of the radiated gauge boson */ Lorentz5Momentum gauge_; /** * The Z boson */ PPtr zboson_; /** * Higgs mass squared */ Energy2 mz2_; //@} }; } #include "ThePEG/Utilities/ClassTraits.h" namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of SMZFermionsPOWHEGDecayer. */ template <> struct BaseClassTrait { /** Typedef of the first base class of SMZFermionsPOWHEGDecayer. */ typedef Herwig::SMZDecayer NthBase; }; /** This template specialization informs ThePEG about the name of * the SMZFermionsPOWHEGDecayer class and the shared object where it is defined. */ template <> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Herwig::SMZFermionsPOWHEGDecayer"; } /** * The name of a file containing the dynamic library where the class * SMZFermionsPOWHEGDecayer is implemented. It may also include several, space-separated, * libraries if the class SMZFermionsPOWHEGDecayer depends on other classes (base classes * excepted). In this case the listed libraries will be dynamically * linked in the order they are specified. */ static string library() { return "HwPerturbativeDecay.so"; } }; /** @endcond */ } #endif /* HERWIG_SMZFermionsPOWHEGDecayer_H */ diff --git a/MatrixElement/General/MEff2sv.h b/MatrixElement/General/MEff2sv.h --- a/MatrixElement/General/MEff2sv.h +++ b/MatrixElement/General/MEff2sv.h @@ -1,199 +1,199 @@ // -*- C++ -*- // // MEff2sv.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_MEff2sv_H #define HERWIG_MEff2sv_H // // This is the declaration of the MEff2sv class. // #include "GeneralHardME.h" #include "ThePEG/Helicity/Vertex/AbstractFFSVertex.h" #include "ThePEG/Helicity/Vertex/AbstractFFVVertex.h" #include "ThePEG/Helicity/Vertex/AbstractVSSVertex.h" #include "ThePEG/Helicity/Vertex/AbstractVVSVertex.h" #include "ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h" #include "ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h" #include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h" #include "ThePEG/Helicity/WaveFunction/ScalarWaveFunction.h" #include "Herwig/MatrixElement/ProductionMatrixElement.h" namespace Herwig { using namespace ThePEG; using Helicity::SpinorWaveFunction; using Helicity::SpinorBarWaveFunction; using Helicity::VectorWaveFunction; using Helicity::ScalarWaveFunction; /** * The MEff2sv class is designed to implement the matrix element for a * fermion-antifermion to vector-scalar hard process. It inherits from * GeneralHardME and implements the appropriate virtual functions for this * specific spin combination. * * @see \ref MEff2svInterfaces "The interfaces" * defined for MEff2sv. * @see GeneralHardME */ class MEff2sv: public GeneralHardME { public: /** @name Typedefs */ //@{ /** * A vector of SpinorWaveFunctions */ typedef vector SpinorVector; /** * A vector of SpinorWaveBarFunctions */ typedef vector SpinorBarVector; /** * A vector of VectorWaveFunctions */ typedef vector VBVector; //@} public: /** * The default constructor. */ MEff2sv() : scalar_(0), vector_(0), fermion_(0) {} /** @name Virtual functions required by the MEBase class. */ //@{ /** * The matrix element for the kinematical configuration * previously provided by the last call to setKinematics(), suitably * scaled by sHat() to give a dimension-less number. * @return the matrix element scaled with sHat() to give a * dimensionless number. */ virtual double me2() const; //@} /** * Construct the vertex information for the spin correlations * @param sub Pointer to the relevent SubProcess */ virtual void constructVertex(tSubProPtr sub); public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const {return new_ptr(*this);} /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const {return new_ptr(*this);} //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - MEff2sv & operator=(const MEff2sv &); + MEff2sv & operator=(const MEff2sv &) = delete; private: /** @name Functions to compute the ProductionMatrixElement. */ //@{ /** * Compute the matrix element for \f$\Psi\bar{\Psi}\to\Psi\bar{\Psi}\f$ * @param sp Spinors for first incoming particle * @param spbar SpinorBar Wavefunctions for second incoming particle * @param vec VectorWaveFunctions for outgoing vector * @param sca Outgoing ScalarWaveFunction * @param me2 colour averaged, spin summed ME * @param first Whether or not first call to decide if colour decomposition etc * should be calculated * @return ProductionMatrixElement containing results of * helicity calculations */ ProductionMatrixElement ffb2svHeME(SpinorVector & sp, SpinorBarVector & spbar, ScalarWaveFunction & sca, VBVector & vec, double & me2,bool first) const; //@} private: /** * Storage for dynamically cast vertices for a diagram with intermediate * scalar */ vector > scalar_; /** * Storage for dynamically cast vertices for a diagram with intermediate * vector */ vector > vector_; /** * Storage for dynamically cast vertices for a diagram with intermediate * fermion */ vector > fermion_; }; } #endif /* HERWIG_MEff2sv_H */ diff --git a/Shower/Core/Base/ShowerKinematics.h b/Shower/Core/Base/ShowerKinematics.h --- a/Shower/Core/Base/ShowerKinematics.h +++ b/Shower/Core/Base/ShowerKinematics.h @@ -1,276 +1,276 @@ // -*- C++ -*- // // ShowerKinematics.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_ShowerKinematics_H #define HERWIG_ShowerKinematics_H // // This is the declaration of the ShowerKinematics class. // #include "Herwig/Shower/Core/ShowerConfig.h" #include "ThePEG/Config/ThePEG.h" #include "Herwig/Shower/Core/Base/SudakovFormFactor.h" #include "ShowerKinematics.fh" namespace Herwig { using namespace ThePEG; /**\ingroup Shower * * This is the abstract base class from which all other shower * kinematics classes derive. The main purpose of the * shower kinematics classes is to allow the reconstruction * of jet masses, at the end of the showering (indeed, for * multi-scale showering, at the end of each scale-range evolution). * This is necessary for the kinematics reshuffling * in order to compensate the recoil of the emissions. * The KinematicsReconstructor class is in * charge of this job, and which is the main "user" of * ShowerKinematics and its derived classes. * How this is done depends on the choice of kinematics variables * and whether the jet is time-like (forward evolved) or * space-like (backward evolved), whereas the class ShowerKinematics * describes only the common features which are independent by them. * * In general there are a number of methods specific to a shower approach * * @see KinematicsReconstructor */ class ShowerKinematics: public Base { public: /** * The default constructor. */ ShowerKinematics() : Base(), _isTheJetStartingPoint( false ), _scale(), _z( 0.0 ), _phi( 0.0 ), _pt(), _sudakov() {} /** * The updateChildren and updateParent * members to update the values of the \f$\alpha\f$ and * \f$p_\perp\f$ variables during the shower evolution. */ //@{ /** * Along with the showering evolution --- going forward for * time-like (forward) evolution, and going backward for space-like * (backward) evolution --- the kinematical variables of the * branching products are calculated and updated from the knowledge * of the parent kinematics. * @param parent The parent * @param children The children * @param partnerType The type of evolution partner */ virtual void updateChildren(const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType, bool massVeto ) const; virtual void resetChildren( const tShowerParticlePtr parent, const ShowerParticleVector & children) const; /** * Update the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the KinematicsReconstructor. * @param parent The parent * @param children The children * @param partnerType The type of evolution partner */ virtual void updateParent(const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType) const; /** * Update the kinematical data of a particle when a reconstruction * fixpoint was found. This will highly depend on the kind of * kinematics chosen and will be defined in the inherited concrete * classes. This method will be used by the KinematicsReconstructor. * @param last The particle. * @param px The \f$x\f$ component of the \f$p_T\f$. * @param py The \f$y\f$ component of the \f$p_T\f$. */ virtual void updateLast(const tShowerParticlePtr last, Energy px, Energy py) const; //@} /** * The reconstructLast, reconstructChildren and reconstructParent members * are used during the reconstruction */ //@{ /** * Along with the showering evolution --- going forward for * time-like (forward) evolution, and going backward for space-like * (backward) evolution --- the kinematical variables of the * branching products are calculated and updated from the knowledge * of the parent kinematics. * @param parent The parent * @param children The children */ virtual void reconstructChildren(const tShowerParticlePtr parent, const ShowerParticleVector & children) const; /** * Reconstruct the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the KinematicsReconstructor. * @param parent The parent * @param children The children */ virtual void reconstructParent(const tShowerParticlePtr parent, const ParticleVector & children) const; /** * Update the kinematical data of a particle when a reconstruction * fixpoint was found. This will highly depend on the kind of * kinematics chosen and will be defined in the inherited concrete * classes. This method will be used by the KinematicsReconstructor. * @param last The particle. * @param mass The mass to be used, if less than zero on-shell */ virtual void reconstructLast(const tShowerParticlePtr last, Energy mass=-1.*GeV) const; //@} public: /** * Set/access the flag that tells whether or not this ShowerKinematics * object is associated to the starting particle of the jet: only in this * case it is sensible to use the two main virtual methods below. */ //@{ /** * Set the starting point flag */ void isTheJetStartingPoint(const bool ); /** * Get the starting point flag */ bool isTheJetStartingPoint() const; //@} /** * Set/Get methods for the kinematic variables */ //@{ /** * Access the scale of the splitting. */ Energy scale() const { return _scale; } /** * Set the scale of the splitting. */ void scale(const Energy in) { _scale=in; } /** * Access the energy fraction, \f$z\f$. */ double z() const { return _z; } /** * Set the energy fraction, \f$z\f$. */ void z(const double in) { _z=in; } /** * Access the azimuthal angle, \f$\phi\f$. */ double phi() const { return _phi; } /** * Set the azimuthal angle, \f$\phi\f$. */ void phi(const double in) { _phi=in; } /** * Access the relative \f$p_T\f$ for the branching */ Energy pT() const { return _pt; } /** * Set the relative \f$p_T\f$ for the branching */ void pT(const Energy in) const { _pt=in; } //@} /** * Set and get methods for the SplittingFunction object */ //@{ /** * Access the SplittingFunction object responsible of the * eventual branching of this particle. */ tSplittingFnPtr splittingFn() const { return _sudakov-> splittingFn(); } //@} /** * Set and get methods for the SudakovFormFactor object */ /** * Access the SudakovFormFactor object responsible of the * eventual branching of this particle. */ tSudakovPtr SudakovFormFactor() const { return _sudakov; } /** * Set the SudakovFormFactor object responsible of the * eventual branching of this particle. */ void SudakovFormFactor(const tSudakovPtr sud) { _sudakov=sud; } //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ShowerKinematics & operator=(const ShowerKinematics &); + ShowerKinematics & operator=(const ShowerKinematics &) = delete; private: /** * Is this the starting point of the jet */ bool _isTheJetStartingPoint; /** * The \f$\tilde{q}\f$ evolution variable. */ Energy _scale; /** * The energy fraction, \f$z\f$ */ double _z; /** * The azimuthal angle, \f$\phi\f$. */ double _phi; /** * The relative \f$p_T\f$ */ mutable Energy _pt; /** * The splitting function for the branching of the particle */ tSudakovPtr _sudakov; }; } #endif /* HERWIG_ShowerKinematics_H */ diff --git a/Shower/Core/Base/SudakovFormFactor.h b/Shower/Core/Base/SudakovFormFactor.h --- a/Shower/Core/Base/SudakovFormFactor.h +++ b/Shower/Core/Base/SudakovFormFactor.h @@ -1,688 +1,688 @@ // -*- C++ -*- // // SudakovFormFactor.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_SudakovFormFactor_H #define HERWIG_SudakovFormFactor_H // // This is the declaration of the SudakovFormFactor class. // #include "ThePEG/Interface/Interfaced.h" #include "Herwig/Shower/Core/SplittingFunctions/SplittingFunction.h" #include "Herwig/Shower/Core/Couplings/ShowerAlpha.h" #include "Herwig/Shower/Core/SplittingFunctions/SplittingGenerator.fh" #include "ThePEG/Repository/UseRandom.h" #include "ThePEG/PDF/BeamParticleData.h" #include "ThePEG/EventRecord/RhoDMatrix.h" #include "ThePEG/EventRecord/SpinInfo.h" #include "ShowerKinematics.fh" #include "SudakovFormFactor.fh" namespace Herwig { using namespace ThePEG; /** * A typedef for the BeamParticleData */ typedef Ptr::transient_const_pointer tcBeamPtr; /** \ingroup Shower * * This is the definition of the Sudakov form factor class. In general this * is the base class for the implementation of Sudakov form factors in Herwig. * The methods generateNextTimeBranching(), generateNextDecayBranching() and * generateNextSpaceBranching need to be implemented in classes inheriting from this * one. * * In addition a number of methods are implemented to assist with the calculation * of the form factor using the veto algorithm in classes inheriting from this one. * * In general the Sudakov form-factor, for final-state radiation, is given * by * \f[\Delta_{ba}(\tilde{q}_{i+1},\tilde{q}_i)= * \exp\left\{ * -\int^{\tilde{q}^2_i}_{\tilde{q}^2_{i+1}} * \frac{{\rm d}\tilde{q}^2}{\tilde{q}^2} * \int\frac{\alpha_S(z,\tilde{q})}{2\pi} * P_{ba}(z,\tilde{q})\Theta(p_T) * \right\}. * \f] * We can solve this to obtain the next value of the scale \f$\tilde{q}_{i+1}\f$ * given the previous value \f$\tilde{q}_i\f$ * in the following way. First we obtain a simplified form of the integrand * which is greater than or equal to the true integrand for all values of * \f$\tilde{q}\f$. * * In practice it is easiest to obtain this over estimate in pieces. The ShowerAlpha * object contains an over estimate for \f$\alpha_S\f$, the splitting function * contains both an over estimate of the spltting function and its integral * which is needed to compute the over estimate of the \f$\tilde{q}\f$ integrand, * together with an over estimate of the limit of the \f$z\f$ integral. * * This gives an overestimate of the integrand * \f[g(\tilde{q}^2) = \frac{c}{\tilde{q}^2}, \f] * where because the over estimates are chosen to be independent of \f$\tilde{q}\f$ the * parameter * \f[c = \frac{\alpha_{\rm over}}{2\pi}\int^{z_1}_{z_0}P_{\rm over}(z),\f] * is a constant independent of \f$\tilde{q}\f$. * * The guesst() member can then be used to generate generate the value of * \f$\tilde{q}^2\f$ according to this result. This is done by solving the Sudakov * form factor, with the over estimates, is equal to a random number * \f$r\f$ in the interval \f$[0,1]\f$. This gives * \f[\tilde{q}^2_{i+1}=G^{-1}\left[G(\tilde{q}^2_i)+\ln r\right],\f] * where \f$G(\tilde{q}^2)=c\ln(\tilde{q}^2)\f$ is the infinite integral * of \f$g(\tilde{q}^2)\f$ and \f$G^{-1}(x)=\exp\left(\frac{x}c\right)\f$ * is its inverse. * It this case we therefore obtain * \f[\tilde{q}^2_{i+1}=\tilde{q}^2_ir^{\frac1c}.\f] * The value of \f$z\f$ can then be calculated in a similar way * \f[z = I^{-1}\left[I(z_0)+r\left(I(z_1)-I(z_0)\right)\right],\f] * using the guessz() member, * where \f$I=\int P(z){\rm d}z\f$ and \f$I^{-1}\f$ is its inverse. * * The veto algorithm then uses rejection using the ratio of the * true value to the overestimated one to obtain the original distribution. * This is accomplished using the * - alphaSVeto() member for the \f$\alpha_S\f$ veto * - SplittingFnVeto() member for the veto on the value of the splitting function. * in general there must also be a chech that the emission is in the allowed * phase space but this is left to the inheriting classes as it will depend * on the ordering variable. * * The Sudakov form factor for the initial-scale shower is different because * it must include the PDF which guides the backward evolution. * It is given by * \f[\Delta_{ba}(\tilde{q}_{i+1},\tilde{q}_i)= * \exp\left\{ * -\int^{\tilde{q}^2_i}_{\tilde{q}^2_{i+1}} * \frac{{\rm d}\tilde{q}^2}{\tilde{q}^2} * \int\frac{\alpha_S(z,\tilde{q})}{2\pi} * P_{ba}(z,\tilde{q})\frac{x'f_a(\frac{x}z,\tilde{q}^2)}{xf_b(x,\tilde{q^2})} * \right\}, * \f] * where \f$x\f$ is the fraction of the beam momentum the parton \f$b\f$ had before * the backward evolution. * This can be solve in the same way as for the final-state branching but the constant * becomes * \f[c = \frac{\alpha_{\rm over}}{2\pi}\int^{z_1}_{z_0}P_{\rm over}(z)PDF_{\rm max},\f] * where * \f[PDF_{\rm max}=\max\frac{x'f_a(\frac{x}z,\tilde{q}^2)}{xf_b(x,\tilde{q^2})},\f] * which can be set using an interface. * In addition the PDFVeto() member then is needed to implement the relevant veto. * * @see SplittingGenerator * @see SplittingFunction * @see ShowerAlpha * @see \ref SudakovFormFactorInterfaces "The interfaces" * defined for SudakovFormFactor. */ class SudakovFormFactor: public Interfaced { /** * The SplittingGenerator is a friend to insert the particles in the * branchings at initialisation */ friend class SplittingGenerator; public: /** * The default constructor. */ SudakovFormFactor() : pdfmax_(35.0), pdffactor_(0), cutOffOption_(0), a_(0.3), b_(2.3), c_(0.3*GeV), kinCutoffScale_( 2.3*GeV ), vgcut_(0.85*GeV), vqcut_(0.85*GeV), pTmin_(1.*GeV), pT2min_(ZERO), z_( 0.0 ),phi_(0.0), pT_(){} /** * Members to generate the scale of the next branching */ //@{ /** * Return the scale of the next time-like branching. If there is no * branching then it returns ZERO. * @param startingScale starting scale for the evolution * @param ids The PDG codes of the particles in the splitting * @param enhance The radiation enhancement factor * defined. */ virtual ShoKinPtr generateNextTimeBranching(const Energy startingScale, const IdList &ids, const RhoDMatrix & rho, double enhance, double detuning, Energy2 maxQ2)=0; /** * Return the scale of the next space-like decay branching. If there is no * branching then it returns ZERO. * @param startingScale starting scale for the evolution * @param stoppingScale stopping scale for the evolution * @param minmass The minimum mass allowed for the spake-like particle. * @param ids The PDG codes of the particles in the splitting * defined. * @param enhance The radiation enhancement factor */ virtual ShoKinPtr generateNextDecayBranching(const Energy startingScale, const Energy stoppingScale, const Energy minmass, const IdList &ids, const RhoDMatrix & rho, double enhance, double detuning)=0; /** * Return the scale of the next space-like branching. If there is no * branching then it returns ZERO. * @param startingScale starting scale for the evolution * @param ids The PDG codes of the particles in the splitting * @param x The fraction of the beam momentum * defined. * @param beam The beam particle * @param enhance The radiation enhancement factor */ virtual ShoKinPtr generateNextSpaceBranching(const Energy startingScale, const IdList &ids,double x, const RhoDMatrix & rho, double enhance, tcBeamPtr beam, double detuning)=0; //@} /** * Generate the azimuthal angle of the branching for forward evolution * @param particle The branching particle * @param ids The PDG codes of the particles in the branchings * @param The Shower kinematics */ virtual double generatePhiForward(ShowerParticle & particle,const IdList & ids, ShoKinPtr kinematics, const RhoDMatrix & rho)=0; /** * Generate the azimuthal angle of the branching for backward evolution * @param particle The branching particle * @param ids The PDG codes of the particles in the branchings * @param The Shower kinematics */ virtual double generatePhiBackward(ShowerParticle & particle,const IdList & ids, ShoKinPtr kinematics, const RhoDMatrix & rho)=0; /** * Generate the azimuthal angle of the branching for ISR in decays * @param particle The branching particle * @param ids The PDG codes of the particles in the branchings * @param The Shower kinematics */ virtual double generatePhiDecay(ShowerParticle & particle,const IdList & ids, ShoKinPtr kinematics, const RhoDMatrix & rho)=0; /** * Methods to provide public access to the private member variables */ //@{ /** * Return the pointer to the SplittingFunction object. */ tSplittingFnPtr splittingFn() const { return splittingFn_; } /** * Return the pointer to the ShowerAlpha object. */ tShowerAlphaPtr alpha() const { return alpha_; } /** * The type of interaction */ inline ShowerInteraction interactionType() const {return splittingFn_->interactionType();} //@} public: /** * Methods to access the kinematic variables for the branching */ //@{ /** * The energy fraction */ double z() const { return z_; } /** * The azimuthal angle */ double phi() const { return phi_; } /** * The transverse momentum */ Energy pT() const { return pT_; } //@} /** * Access the maximum weight for the PDF veto */ double pdfMax() const { return pdfmax_;} /** * Method to return the evolution scale given the * transverse momentum, \f$p_T\f$ and \f$z\f$. */ virtual Energy calculateScale(double z, Energy pt, IdList ids,unsigned int iopt)=0; /** * Method to create the ShowerKinematics object for a final-state branching */ virtual ShoKinPtr createFinalStateBranching(Energy scale,double z, double phi, Energy pt)=0; /** * Method to create the ShowerKinematics object for an initial-state branching */ virtual ShoKinPtr createInitialStateBranching(Energy scale,double z, double phi, Energy pt)=0; /** * Method to create the ShowerKinematics object for a decay branching */ virtual ShoKinPtr createDecayBranching(Energy scale,double z, double phi, Energy pt)=0; public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} protected: /** * Methods to implement the veto algorithm to generate the scale of * the next branching */ //@{ /** * Value of the energy fraction for the veto algorithm * @param iopt The option for calculating z * @param ids The PDG codes of the particles in the splitting * - 0 is final-state * - 1 is initial-state for the hard process * - 2 is initial-state for particle decays */ double guessz (unsigned int iopt, const IdList &ids) const; /** * Value of the scale for the veto algorithm * @param t1 The starting valoe of the scale * @param iopt The option for calculating t * @param ids The PDG codes of the particles in the splitting * - 0 is final-state * - 1 is initial-state for the hard process * - 2 is initial-state for particle decays * @param enhance The radiation enhancement factor * @param identical Whether or not the outgoing particles are identical */ Energy2 guesst (Energy2 t1,unsigned int iopt, const IdList &ids, double enhance, bool identical, double detune) const; /** * Veto on the PDF for the initial-state shower * @param t The scale * @param x The fraction of the beam momentum * @param parton0 Pointer to the particleData for the * new parent (this is the particle we evolved back to) * @param parton1 Pointer to the particleData for the * original particle * @param beam The BeamParticleData object */ bool PDFVeto(const Energy2 t, const double x, const tcPDPtr parton0, const tcPDPtr parton1, tcBeamPtr beam) const; /** * The PDF veto ratio */ double PDFVetoRatio(const Energy2 t, const double x, const tcPDPtr parton0, const tcPDPtr parton1, tcBeamPtr beam,double factor) const; /** * The veto on the splitting function. * @param t The scale * @param ids The PDG codes of the particles in the splitting * @param mass Whether or not to use the massive splitting functions * @return true if vetoed */ bool SplittingFnVeto(const Energy2 t, const IdList &ids, const bool mass, const RhoDMatrix & rho, double detune) const { return UseRandom::rnd()>SplittingFnVetoRatio(t,ids,mass,rho,detune); } /** * The Splitting function veto ratio */ double SplittingFnVetoRatio(const Energy2 t, const IdList &ids, const bool mass, const RhoDMatrix & rho, double detune) const { return splittingFn_->ratioP(z_, t, ids,mass,rho)/detune; } /** * The veto on the coupling constant * @param pt2 The value of ther transverse momentum squared, \f$p_T^2\f$. * @return true if vetoed */ bool alphaSVeto(Energy2 pt2) const; /** * The alpha S veto ratio */ double alphaSVetoRatio(Energy2 pt2,double factor) const; //@} /** * Methods to set the kinematic variables for the branching */ //@{ /** * The energy fraction */ void z(double in) { z_=in; } /** * The azimuthal angle */ void phi(double in) { phi_=in; } /** * The transverse momentum */ void pT(Energy in) { pT_=in; } //@} /** * Set/Get the limits on the energy fraction for the splitting */ //@{ /** * Get the limits */ pair zLimits() const { return zlimits_;} /** * Set the limits */ void zLimits(pair in) { zlimits_=in; } //@} /** * Set the particles in the splittings */ void addSplitting(const IdList &); /** * Delete the particles in the splittings */ void removeSplitting(const IdList &); /** * Access the potential branchings */ const vector & particles() const { return particles_; } public: /** * @name Methods for the cut-off */ //@{ /** * The option being used */ unsigned int cutOffOption() const { return cutOffOption_; } /** * The kinematic scale */ Energy kinScale() const {return kinCutoffScale_;} /** * The virtuality cut-off on the gluon \f$Q_g=\frac{\delta-am_q}{b}\f$ * @param scale The scale \f$\delta\f$ * @param mq The quark mass \f$m_q\f$. */ Energy kinematicCutOff(Energy scale, Energy mq) const {return max((scale -a_*mq)/b_,c_);} /** * The virtualilty cut-off for gluons */ Energy vgCut() const { return vgcut_; } /** * The virtuality cut-off for everything else */ Energy vqCut() const { return vqcut_; } /** * The minimum \f$p_T\f$ for the branching */ Energy pTmin() const { return pTmin_; } /** * The square of the minimum \f$p_T\f$ */ Energy2 pT2min() const { return pT2min_; } /** * Calculate the virtual masses for a branchings */ const vector & virtualMasses(const IdList & ids); //@} /** * Set the PDF */ void setPDF(tcPDFPtr pdf, Energy scale) { pdf_ = pdf; freeze_ = scale; } private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - SudakovFormFactor & operator=(const SudakovFormFactor &); + SudakovFormFactor & operator=(const SudakovFormFactor &) = delete; private: /** * Pointer to the splitting function for this Sudakov form factor */ SplittingFnPtr splittingFn_; /** * Pointer to the coupling for this Sudakov form factor */ ShowerAlphaPtr alpha_; /** * Maximum value of the PDF weight */ double pdfmax_; /** * List of the particles this Sudakov is used for to aid in setting up * interpolation tables if needed */ vector particles_; /** * Option for the inclusion of a factor \f$1/(1-z)\f$ in the PDF estimate */ unsigned pdffactor_; private: /** * Option for the type of cut-off to be applied */ unsigned int cutOffOption_; /** * Parameters for the default Herwig cut-off option, i.e. the parameters for * the \f$Q_g=\max(\frac{\delta-am_q}{b},c)\f$ kinematic cut-off */ //@{ /** * The \f$a\f$ parameter */ double a_; /** * The \f$b\f$ parameter */ double b_; /** * The \f$c\f$ parameter */ Energy c_; /** * Kinematic cutoff used in the parton shower phase space. */ Energy kinCutoffScale_; //@} /** * Parameters for the FORTRAN-like cut-off */ //@{ /** * The virtualilty cut-off for gluons */ Energy vgcut_; /** * The virtuality cut-off for everything else */ Energy vqcut_; //@} /** * Parameters for the \f$p_T\f$ cut-off */ //@{ /** * The minimum \f$p_T\f$ for the branching */ Energy pTmin_; /** * The square of the minimum \f$p_T\f$ */ Energy2 pT2min_; //@} private: /** * Member variables to keep the shower kinematics information * generated by a call to generateNextTimeBranching or generateNextSpaceBranching */ //@{ /** * The energy fraction */ double z_; /** * The azimuthal angle */ double phi_; /** * The transverse momentum */ Energy pT_; //@} /** * The limits of \f$z\f$ in the splitting */ pair zlimits_; /** * Stuff for the PDFs */ //@{ /** * PDf */ tcPDFPtr pdf_; /** * Freezing scale */ Energy freeze_; //@} }; } #endif /* HERWIG_SudakovFormFactor_H */ diff --git a/Shower/QTilde/Base/KinematicsReconstructor.h b/Shower/QTilde/Base/KinematicsReconstructor.h --- a/Shower/QTilde/Base/KinematicsReconstructor.h +++ b/Shower/QTilde/Base/KinematicsReconstructor.h @@ -1,132 +1,132 @@ // -*- C++ -*- // // KinematicsReconstructor.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_KinematicsReconstructor_H #define HERWIG_KinematicsReconstructor_H // // This is the declaration of the KinematicsReconstructor class. // #include "ThePEG/Interface/Interfaced.h" #include "Herwig/Shower/Core/Base/ShowerParticle.h" #include "Herwig/Shower/Core/Base/ShowerProgenitor.h" #include "Herwig/Shower/Core/Base/ShowerTree.h" #include "Herwig/Shower/Core/Base/HardTree.h" #include "KinematicsReconstructor.fh" #include namespace Herwig { using namespace ThePEG; /**\ingroup Shower * Exception class * used to communicate failure of kinematics * reconstruction. */ struct KinematicsReconstructionVeto {}; /** \ingroup Shower * * This class is responsible for the kinematical reconstruction * after each showering step, and also for the necessary Lorentz boosts * in order to preserve energy-momentum conservation in the overall collision, * and also the invariant mass and the rapidity of the hard subprocess system. * In the case of multi-step showering, there will be not unnecessary * kinematical reconstructions. * * Notice: * - although we often use the term "jet" in either methods or variables names, * or in comments, which could appear applicable only for QCD showering, * there is indeed no "dynamics" represented in this class: only kinematics * is involved, as the name of this class remainds. Therefore it can be used * for any kind of showers (QCD-,QED-,EWK-,... bremsstrahlung). * * @see \ref KinematicsReconstructorInterfaces "The interfaces" * defined for KinematicsReconstructor. */ class KinematicsReconstructor: public Interfaced { public: /** * Methods to reconstruct the kinematics of a scattering or decay process */ //@{ /** * Given the ShowerTree for the shower from a hard process * the method does the reconstruction of the jets, * including the appropriate boosts (kinematics reshufflings) * needed to conserve the total energy-momentum of the collision * and preserving the invariant mass and the rapidity of the * hard subprocess system. */ virtual bool reconstructHardJets(ShowerTreePtr hard, const map > & pt, ShowerInteraction type, bool switchRecon) const=0; /** * Given the ShowerTree for a decay shower * the method does the reconstruction of the jets, * including the appropriate boosts (kinematics reshufflings) * needed to conserve the total energy-momentum of the collision * and preserving the invariant mass and the rapidity of the * hard subprocess system. */ virtual bool reconstructDecayJets(ShowerTreePtr decay, ShowerInteraction type) const=0; //@} /** * Methods to invert the reconstruction of the shower for * a scattering or decay process and calculate * the variables used to generate the * shower given the particles produced. * This is needed for the CKKW and POWHEG approaches */ //@{ /** * Given the particles, with a history which we wish to interpret * as a shower reconstruct the variables used to generate the * shower for a decay process */ virtual bool deconstructDecayJets(HardTreePtr decay,ShowerInteraction) const=0; /** * Given the particles, with a history which we wish to interpret * as a shower reconstruct the variables used to generate the shower * for a hard process */ virtual bool deconstructHardJets(HardTreePtr hard,ShowerInteraction) const=0; //@} public: /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - KinematicsReconstructor & operator=(const KinematicsReconstructor &); + KinematicsReconstructor & operator=(const KinematicsReconstructor &) = delete; }; } #endif /* HERWIG_KinematicsReconstructor_H */ diff --git a/Shower/QTilde/Base/ShowerModel.h b/Shower/QTilde/Base/ShowerModel.h --- a/Shower/QTilde/Base/ShowerModel.h +++ b/Shower/QTilde/Base/ShowerModel.h @@ -1,148 +1,148 @@ // -*- C++ -*- // // ShowerModel.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_ShowerModel_H #define HERWIG_ShowerModel_H // // This is the declaration of the ShowerModel class. // #include "ThePEG/Interface/Interfaced.h" #include "KinematicsReconstructor.fh" #include "PartnerFinder.fh" #include "Herwig/Shower/Core/Base/SudakovFormFactor.fh" #include "ShowerModel.fh" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * The ShowerModel class is a container for all the objects needed to implement a * specific model of the shower evolution, as opposed to those which are independent * of the evolution. * * In general there are four types of object * - The KinematicsReconstructor object which is responsible for reconstruction * of the shower kinematics after the evolution. * - The PartnerFinder which is responsible for finding the partner and setting the * initial evolution scale * - A vector of SudakovFormFactor objects which will usually all be instances * of a class implementing the SudakovFormFactor for a specific model with * different splitting functions for different branchings * * For each model the checkConsistency member must be implemented to check that * the correct objects for the model are used. * * @see \ref ShowerModelInterfaces "The interfaces" * defined for ShowerModel. */ class ShowerModel: public Interfaced { public: /** * Access methods to access the objects */ //@{ /** * Access to the KinematicsReconstructor object */ tKinematicsReconstructorPtr kinematicsReconstructor() const { return _reconstructor; } /** * Access to the PartnerFinder object */ tPartnerFinderPtr partnerFinder() const { return _partnerfinder; } /** * Access to the SudakovFormFactor objects */ const vector & sudakovFormFactors() const { return _sudakovs; } //@} public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** * The checkConsitency member which must be implemented in classes * inheriting from this one. */ virtual void checkConsistency() =0; /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ShowerModel & operator=(const ShowerModel &); + ShowerModel & operator=(const ShowerModel &) = delete; private: /** * Pointer to the various objects */ //@{ /** * Pointer to the KinematicsReconstructor object */ KinematicsReconstructorPtr _reconstructor; /** * Pointer to the PartnerFinder object */ PartnerFinderPtr _partnerfinder; /** * Pointers to the SudakovFormFactor objects */ vector _sudakovs; //@} }; } #endif /* HERWIG_ShowerModel_H */ diff --git a/Shower/QTilde/Couplings/ShowerAlphaQCD.h b/Shower/QTilde/Couplings/ShowerAlphaQCD.h --- a/Shower/QTilde/Couplings/ShowerAlphaQCD.h +++ b/Shower/QTilde/Couplings/ShowerAlphaQCD.h @@ -1,308 +1,308 @@ // -*- C++ -*- // // ShowerAlphaQCD.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_ShowerAlphaQCD_H #define HERWIG_ShowerAlphaQCD_H // // This is the declaration of the ShowerAlphaQCD class. // #include "Herwig/Shower/Core/Couplings/ShowerAlpha.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * This concrete class provides the definition of the * pure virtual function value() and overestimateValue() for the * strong coupling. * * A number of different options for the running of the coupling * and its initial definition are supported. * * @see \ref ShowerAlphaQCDInterfaces "The interfaces" * defined for ShowerAlphaQCD. */ class ShowerAlphaQCD: public ShowerAlpha { public: /** * The default constructor. */ ShowerAlphaQCD() : ShowerAlpha(), _qmin(0.630882*GeV), _asType(1), _asMaxNP(1.0), _thresholds(4), _lambda(4), _nloop(3),_lambdaopt(false),_thresopt(false), _lambdain(0.208364*GeV),_alphain(0.118),_inopt(true),_tolerance(1e-10), _maxtry(100),_alphamin(0.),_val0(1.), _optInputScale(ZERO) {} public: /** * Methods to return the coupling */ //@{ /** * It returns the running coupling value evaluated at the input scale * multiplied by the scale factor scaleFactor(). * @param scale The scale * @return The coupling */ virtual double value(const Energy2 scale) const; /** * It returns the running coupling value evaluated at the input scale * multiplied by the scale factor scaleFactor(). */ virtual double overestimateValue() const; /** * Return the ratio of the coupling at the scale to the overestimated value */ virtual double ratio(const Energy2 scale,double factor =1.) const; /** * Initialize this coupling. */ virtual void initialize() { doinit(); } /** * A command to initialize the coupling and write * its value at the scale given by the argument (in GeV) */ string value(string); /** * Match thresholds and write alpha_s * specified file; arguments are * Q_low/GeV Q_high/GeV n_steps filename */ string check(string args); //@} /** * Get the value of \f$\Lambda_{\rm QCd}\f$ * @param nf number of flavours */ Energy lambdaQCD(unsigned int nf) { if (nf <= 3) return _lambda[0]; else if (nf==4 || nf==5) return _lambda[nf-3]; else return _lambda[3]; } /** * Return the quark masses to be used; if not empty these masses * should be considered instead of the ones set in the particle data * objects. */ const vector& quarkMasses() const { return _quarkMasses; } public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} private: /** * Member functions which calculate the coupling */ //@{ /** * The 1,2,3-loop parametrization of \f$\alpha_S\f$. * @param q The scale * @param lam \f$\Lambda_{\rm QCD}\f$ * @param nf The number of flavours */ double alphaS(Energy q, Energy lam, int nf) const; /** * The derivative of \f$\alpha_S\f$ with respect to \f$\ln(Q^2/\Lambda^2)\f$ * @param q The scale * @param lam \f$\Lambda_{\rm QCD}\f$ * @param nf The number of flavours */ double derivativealphaS(Energy q, Energy lam, int nf) const; /** * Compute the value of \f$Lambda\f$ needed to get the input value of * the strong coupling at the scale given for the given number of flavours * using the Newton-Raphson method * @param match The scale for the coupling * @param alpha The input coupling * @param nflav The number of flavours */ Energy computeLambda(Energy match, double alpha, unsigned int nflav) const; /** * Return the value of \f$\Lambda\f$ and the number of flavours at the scale. * @param q The scale * @return The number of flavours at the scale and \f$\Lambda\f$. */ pair getLamNfTwoLoop(Energy q) const; //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - ShowerAlphaQCD & operator=(const ShowerAlphaQCD &); + ShowerAlphaQCD & operator=(const ShowerAlphaQCD &) = delete; private: /** * Minimum value of the scale */ Energy _qmin; /** * Parameter controlling the behaviour of \f$\alpha_S\f$ in the * non-perturbative region. */ int _asType; /** * Another parameter, a possible (maximum) value of alpha in the * non-perturbative region. */ double _asMaxNP; /** * Thresholds for the different number of flavours */ vector _thresholds; /** * \f$\Lambda\f$ for the different number of flavours */ vector _lambda; /** * Option for the number of loops */ unsigned int _nloop; /** * Option for the translation between \f$\Lambda_{\bar{MS}}\f$ and * \f$\Lambda_{\rm Herwig}\f$ */ bool _lambdaopt; /** * Option for the threshold masses */ bool _thresopt; /** * Input value of Lambda */ Energy _lambdain; /** * Input value of \f$alpha_S(M_Z)\f$ */ double _alphain; /** * Option for the calculation of Lambda from input parameters */ bool _inopt; /** * Tolerance for discontinuities at the thresholds */ double _tolerance; /** * Maximum number of iterations for the Newton-Raphson method to converge */ unsigned int _maxtry; /** * The minimum value of the coupling */ double _alphamin; /** * Value of \f$\alpha_S\f$ at the minimum scale */ double _val0; /** * An optional input scale to be used for the input alphas; if zero MZ will * be used out of the particle data object. */ Energy _optInputScale; /** * The quark masses to be used; if not empty these masses should be * considered instead of the ones set in the particle data objects. */ vector _quarkMasses; }; } #endif /* HERWIG_ShowerAlphaQCD_H */ diff --git a/Shower/QTilde/Default/Decay_QTildeShowerKinematics1to2.h b/Shower/QTilde/Default/Decay_QTildeShowerKinematics1to2.h --- a/Shower/QTilde/Default/Decay_QTildeShowerKinematics1to2.h +++ b/Shower/QTilde/Default/Decay_QTildeShowerKinematics1to2.h @@ -1,101 +1,101 @@ // -*- C++ -*- // // Decay_QTildeShowerKinematics1to2.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_Decay_QTildeShowerKinematics1to2_H #define HERWIG_Decay_QTildeShowerKinematics1to2_H // // This is the declaration of the Decay_QTildeShowerKinematics1to2 class. // #include "Herwig/Shower/Core/Base/ShowerKinematics.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * This (concrete) class provides the specific decay shower * kinematics information. * * @see ShowerKinematics * @see IS_QTildeShowerKinematics1to2 * @see FS_QTildeShowerKinematics1to2 * @see KinematicsReconstructor * */ class Decay_QTildeShowerKinematics1to2: public ShowerKinematics { public: /** * The updateChildren, updateParent and updateLast * members to update the values of the \f$\alpha\f$ and * \f$p_\perp\f$ variables during the shower evolution. */ //@{ /** * Along with the showering evolution --- going forward for * time-like (forward) evolution, and going backward for space-like * (backward) evolution --- the kinematical variables of the * branching products are calculated and updated from the knowledge * of the parent kinematics. This method is used by the * ForwardShowerEvolver. * @param parent The branching particle * @param children The particles produced in the branching * @param partnerType The type of evolution partner */ virtual void updateChildren( const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType, bool massVeto) const; /** * Update the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the * KinematicsReconstructor. */ virtual void reconstructParent( const tShowerParticlePtr parent, const ParticleVector & children ) const; /** * Update the kinematical data of a particle when a reconstruction * fixpoint was found. This will highly depend on the kind of * kinematics chosen and will be defined in the inherited concrete * classes. This method will be used by the KinematicsReconstructor. * @param last The particle to update * @param mass The mass to be used, if less than zero on-shell */ virtual void reconstructLast(const tShowerParticlePtr last, Energy mass=-1.*GeV) const; /** * Update the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the KinematicsReconstructor. * @param parent The parent * @param children The children * @param partnerType The type of evolution partner */ virtual void updateParent(const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType) const; //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - Decay_QTildeShowerKinematics1to2 & operator=(const Decay_QTildeShowerKinematics1to2 &); + Decay_QTildeShowerKinematics1to2 & operator=(const Decay_QTildeShowerKinematics1to2 &) = delete; }; } #endif /* HERWIG_Decay_QTildeShowerKinematics1to2_H */ diff --git a/Shower/QTilde/Default/FS_QTildeShowerKinematics1to2.h b/Shower/QTilde/Default/FS_QTildeShowerKinematics1to2.h --- a/Shower/QTilde/Default/FS_QTildeShowerKinematics1to2.h +++ b/Shower/QTilde/Default/FS_QTildeShowerKinematics1to2.h @@ -1,117 +1,117 @@ // -*- C++ -*- // // FS_QTildeShowerKinematics1to2.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_FS_QTildeShowerKinematics1to2_H #define HERWIG_FS_QTildeShowerKinematics1to2_H // // This is the declaration of the FS_QTildeShowerKinematics1to2 class. // #include "Herwig/Shower/Core/Base/ShowerKinematics.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * This (concrete) class provides the specific Final State shower * kinematics information. * * @see ShowerKinematics * @see IS_QTildeShowerKinematics1to2 * @see Decay_QTildeShowerKinematics1to2 * @see KinematicsReconstructor */ class FS_QTildeShowerKinematics1to2: public ShowerKinematics { public: /** * Default constructor */ inline FS_QTildeShowerKinematics1to2() {} /** * The updateChildren, updateParent and updateLast * members to update the values of the \f$\alpha\f$ and * \f$p_\perp\f$ variables during the shower evolution. */ //@{ /** * Along with the showering evolution --- going forward for * time-like (forward) evolution, and going backward for space-like * (backward) evolution --- the kinematical variables of the * branching products are calculated and updated from the knowledge * of the parent kinematics. This method is used by the * ForwardShowerEvolver. * @param parent The branching particle * @param children The particles produced in the branching * @param partnerType The type of evolution partner */ private: void updateParameters(tShowerParticlePtr theParent, tShowerParticlePtr theChild0, tShowerParticlePtr theChild1, bool setAlpha) const; public: virtual void updateChildren( const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType, bool massVeto ) const; virtual void resetChildren( const tShowerParticlePtr parent, const ShowerParticleVector & children) const; /** * Update the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the KinematicsReconstructor. * @param parent The parent * @param children The children * @param partnerType The type of evolution partner */ virtual void updateParent(const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType) const; /** * Update the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the * KinematicsReconstructor. */ virtual void reconstructParent( const tShowerParticlePtr parent, const ParticleVector & children ) const; /** * Update the kinematical data of a particle when a reconstruction * fixpoint was found. This will highly depend on the kind of * kinematics chosen and will be defined in the inherited concrete * classes. This method will be used by the KinematicsReconstructor. * @param last The particle to update * @param mass The mass to be used, if less than zero on-shell */ virtual void reconstructLast(const tShowerParticlePtr last, Energy mass=-1.*GeV) const; //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - FS_QTildeShowerKinematics1to2 & operator=(const FS_QTildeShowerKinematics1to2 &); + FS_QTildeShowerKinematics1to2 & operator=(const FS_QTildeShowerKinematics1to2 &) = delete; }; } #endif /* HERWIG_FS_QTildeShowerKinematics1to2_H */ diff --git a/Shower/QTilde/Default/IS_QTildeShowerKinematics1to2.h b/Shower/QTilde/Default/IS_QTildeShowerKinematics1to2.h --- a/Shower/QTilde/Default/IS_QTildeShowerKinematics1to2.h +++ b/Shower/QTilde/Default/IS_QTildeShowerKinematics1to2.h @@ -1,112 +1,112 @@ // -*- C++ -*- // // IS_QTildeShowerKinematics1to2.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_IS_QTildeShowerKinematics1to2_H #define HERWIG_IS_QTildeShowerKinematics1to2_H // // This is the declaration of the IS_QTildeShowerKinematics1to2 class. // #include "Herwig/Shower/Core/Base/ShowerKinematics.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * This (concrete) class provides the specific Intial State shower * kinematics information. * * @see ShowerKinematics * @see FS_QTildeShowerKinematics1to2 * @see Decay_QTildeShowerKinematics1to2 * @see KinematicsReconstructor */ class IS_QTildeShowerKinematics1to2: public ShowerKinematics { public: /** @name Standard constructors and destructors. */ //@{ /** * Construct in terms of the basis states */ inline IS_QTildeShowerKinematics1to2() {} //@} public: /** * The updateChildren, updateParent and updateLast * members to update the values of the \f$\alpha\f$ and * \f$p_\perp\f$ variables during the shower evolution. */ //@{ /** * Along with the showering evolution --- going forward for * time-like (forward) evolution, and going backward for space-like * (backward) evolution --- the kinematical variables of the * branching products are calculated and updated from the knowledge * of the parent kinematics. This method is used by the * ForwardShowerEvolver. * @param parent The branching particle * @param children The particles produced in the branching * @param partnerType The type of evolution partner */ virtual void updateChildren( const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType, bool massVeto) const; /** * Update the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the * KinematicsReconstructor. * @param parent The branching particle * @param children The particles produced in the branching * @param partnerType The type of evolution partner */ virtual void updateParent( const tShowerParticlePtr parent, const ShowerParticleVector & children, ShowerPartnerType partnerType) const; /** * Update the parent Kinematics from the knowledge of the kinematics * of the children. This method will be used by the * KinematicsReconstructor. */ virtual void reconstructParent( const tShowerParticlePtr parent, const ParticleVector & children ) const; /** * Update the kinematical data of a particle when a reconstruction * fixpoint was found. This will highly depend on the kind of * kinematics chosen and will be defined in the inherited concrete * classes. This method will be used by the KinematicsReconstructor. * @param theLast The particle. * @param px The \f$x\f$ component of the \f$p_T\f$. * @param py The \f$y\f$ component of the \f$p_T\f$. */ virtual void updateLast(const tShowerParticlePtr theLast, Energy px, Energy py) const; //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - IS_QTildeShowerKinematics1to2 & operator=(const IS_QTildeShowerKinematics1to2 &); + IS_QTildeShowerKinematics1to2 & operator=(const IS_QTildeShowerKinematics1to2 &) = delete; }; } #endif /* HERWIG_IS_QTildeShowerKinematics1to2_H */ diff --git a/Shower/QTilde/Default/QTildeFinder.h b/Shower/QTilde/Default/QTildeFinder.h --- a/Shower/QTilde/Default/QTildeFinder.h +++ b/Shower/QTilde/Default/QTildeFinder.h @@ -1,206 +1,206 @@ // -*- C++ -*- // // QTildeFinder.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_QTildeFinder_H #define HERWIG_QTildeFinder_H // // This is the declaration of the QTildeFinder class. // #include "Herwig/Shower/QTilde/Base/PartnerFinder.h" #include "Herwig/Shower/Core/ShowerConfig.h" #include "ThePEG/Interface/Interfaced.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * The QTildeFinder class is responsible for finding the partners and * setting the initial evolution scales for the shower evolution described * in JHEP 0312:045,2003. * * @see \ref QTildeFinderInterfaces "The interfaces" * defined for QTildeFinder. */ class QTildeFinder: public PartnerFinder { public: /** * The default constructor. */ QTildeFinder() : _finalFinalConditions(0), _initialFinalDecayConditions(0), _initialInitialConditions(0) {} /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); public: /** * Calculate the initial evolution scales given momenta */ pair calculateFinalFinalScales(Lorentz5Momentum p1, Lorentz5Momentum p2, bool colouredfirst); /** * Calculate the initial evolution scales given momenta */ pair calculateInitialInitialScales(const Lorentz5Momentum& p1, const Lorentz5Momentum& p2); /** * Calculate the initial evolution scales given momenta */ pair calculateInitialFinalScales(const Lorentz5Momentum& pb, const Lorentz5Momentum& pc, const bool isDecayCase); protected: /** * Given a pair of particles, supposedly partners w.r.t. an interaction, * this method returns their initial evolution scales as a pair. * If something wrong happens, it returns the null (ZERO,ZERO) pair. * This method is used by the above setXXXInitialEvolutionScales * methods. */ //@{ /** * Calculate the initial evolution scales for two final-state particles */ virtual pair calculateFinalFinalScales(const ShowerPPair &); /** * Calculate the initial evolution scales for two initial-state particles */ virtual pair calculateInitialInitialScales(const ShowerPPair &); /** * Calculate the initial evolution scales for one initial * and one final-state particles */ virtual pair calculateInitialFinalScales(const ShowerPPair &, const bool isDecayCase); //@} /** * Access function for the initial conditions for the shower */ //@{ /** * Initial conditions for the shower of a final-final colour connection * - 0 is the symmetric choice * - 1 is maximal emmision from the coloured particle * - 2 is maximal emmision from the anticoloured particle * - 3 is randomly selected maximal emmision */ unsigned int finalFinalConditions() const {return _finalFinalConditions;} /** * Initial conditions for the shower of an initial-final decay colour connection * - 0 is the symmetric choice * - 1 is maximal emission from the decay product * - 2 is the smooth choice */ unsigned int initialFinalDecayConditions() const {return _initialFinalDecayConditions;} //@} protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const {return new_ptr(*this);} /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const {return new_ptr(*this);} //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - QTildeFinder & operator=(const QTildeFinder &); + QTildeFinder & operator=(const QTildeFinder &) = delete; private: /** * Flags controlling the initial conditions for the shower */ //@{ /** * Initial conditions for the shower with a final-final colour * connection */ unsigned int _finalFinalConditions; /** * Initial conditions for the shower with an initial-final decay colour * connection. This is done according to the top decay colour * connection calculation in JHEP12(2003)_045. The options act as follows: * 0: This is the default 'symmetric' choice which more or less divides * the phase space evenly between the parent and its charged child. * 1: This 'maximal' choice maximises the phase space available for * gluons emitted from the charged child. * 2: This (experimental) 'smooth' choice does not suffer from * a discontinuity at the boundary between the region populated by * emissions from the charged child and the region populated by emissions * from the parent. This does, however, mean that the phase space * available for emissions from the charged child is fairly minimal. */ unsigned int _initialFinalDecayConditions; /** * Initial conditions for the shower with an initial-initial colour * connection. This is done according to the colour connection * calculation in JHEP12(2003)_045. The options act as follows: * 0: This is the default 'symmetric' choice which more or less divides * the phase space evenly between the two incoming partons. * 1: This increases the phase space for emission from "parton b". * 2: This increases the phase space for emission from "parton c". */ unsigned int _initialInitialConditions; //@} }; } #endif /* HERWIG_QTildeFinder_H */ diff --git a/Shower/QTilde/Default/QTildeModel.h b/Shower/QTilde/Default/QTildeModel.h --- a/Shower/QTilde/Default/QTildeModel.h +++ b/Shower/QTilde/Default/QTildeModel.h @@ -1,77 +1,77 @@ // -*- C++ -*- // // QTildeModel.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_QTildeModel_H #define HERWIG_QTildeModel_H // // This is the declaration of the QTildeModel class. // #include "Herwig/Shower/QTilde/Base/ShowerModel.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * The QTildeModel class inherits from the ShowerModel class and implements the * checkConsistency member for the default Herwig Shower. * * @see \ref QTildeModelInterfaces "The interfaces" * defined for QTildeModel. */ class QTildeModel: public ShowerModel { public: /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** * The implementation of the virtual member from the base class to * check that the correct objects are loaded */ virtual void checkConsistency(); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - QTildeModel & operator=(const QTildeModel &); + QTildeModel & operator=(const QTildeModel &) = delete; }; } #endif /* HERWIG_QTildeModel_H */ diff --git a/Shower/QTilde/Default/QTildeReconstructor.h b/Shower/QTilde/Default/QTildeReconstructor.h --- a/Shower/QTilde/Default/QTildeReconstructor.h +++ b/Shower/QTilde/Default/QTildeReconstructor.h @@ -1,642 +1,642 @@ // -*- C++ -*- // // QTildeReconstructor.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_QTildeReconstructor_H #define HERWIG_QTildeReconstructor_H // // This is the declaration of the QTildeReconstructor class. // #include "Herwig/Shower/QTilde/Base/KinematicsReconstructor.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * A simple struct to store the information we need on the * showering */ struct JetKinStruct { /** * Parent particle of the jet */ tShowerParticlePtr parent; /** * Momentum of the particle before reconstruction */ Lorentz5Momentum p; /** * Momentum of the particle after reconstruction */ Lorentz5Momentum q; }; /** * typedef for a vector of JetKinStruct */ typedef vector JetKinVect; /** * Enum to identify types of colour singlet systems */ enum SystemType { UNDEFINED=-1, II, IF, F ,I }; /** * Struct to store colour singlets */ template struct ColourSinglet { typedef vector > VecType; ColourSinglet() : type(UNDEFINED) {} ColourSinglet(SystemType intype,Value inpart) : type(intype),jets(1,inpart) {} /** * The type of system */ SystemType type; /** * The jets in the system */ vector jets; }; /** * Struct to store a colour singlet system of particles */ typedef ColourSinglet ColourSingletSystem; /** * Struct to store a colour singlet shower */ typedef ColourSinglet ColourSingletShower; /** \ingroup Shower * * This class is responsible for the kinematical reconstruction * after each showering step, and also for the necessary Lorentz boosts * in order to preserve energy-momentum conservation in the overall collision, * and also the invariant mass and the rapidity of the hard subprocess system. * In the case of multi-step showering, there will be not unnecessary * kinematical reconstructions. * * There is also the option of taking a set of momenta for the particles * and inverting the reconstruction to give the evolution variables for the * shower. * * Notice: * - although we often use the term "jet" in either methods or variables names, * or in comments, which could appear applicable only for QCD showering, * there is indeed no "dynamics" represented in this class: only kinematics * is involved, as the name of this class remainds. Therefore it can be used * for any kind of showers (QCD-,QED-,EWK-,... bremsstrahlung). * * @see ShowerParticle * @see ShowerKinematics * @see \ref QTildeReconstructorInterfaces "The interfaces" * defined for QTildeReconstructor. */ class QTildeReconstructor: public KinematicsReconstructor { public: /** * Default constructor */ QTildeReconstructor() : _reconopt(0), _initialBoost(0), _finalStateReconOption(0), _initialStateReconOption(0), _minQ(MeV) {}; /** * Methods to reconstruct the kinematics of a scattering or decay process */ //@{ /** * Given in input a vector of the particles which initiated the showers * the method does the reconstruction of such jets, * including the appropriate boosts (kinematics reshufflings) * needed to conserve the total energy-momentum of the collision * and preserving the invariant mass and the rapidity of the * hard subprocess system. */ virtual bool reconstructHardJets(ShowerTreePtr hard, const map > & pt, ShowerInteraction type, bool switchRecon) const; /** * Given in input a vector of the particles which initiated the showers * the method does the reconstruction of such jets, * including the appropriate boosts (kinematics reshufflings) * needed to conserve the total energy-momentum of the collision * and preserving the invariant mass and the rapidity of the * hard subprocess system. */ virtual bool reconstructDecayJets(ShowerTreePtr decay, ShowerInteraction type) const; //@} /** * Methods to invert the reconstruction of the shower for * a scattering or decay process and calculate * the variables used to generate the * shower given the particles produced. * This is needed for the CKKW and POWHEG approaches */ //@{ /** * Given the particles, with a history which we wish to interpret * as a shower reconstruct the variables used to generate the * shower */ virtual bool deconstructDecayJets(HardTreePtr,ShowerInteraction) const; /** * Given the particles, with a history which we wish to interpret * as a shower reconstruct the variables used to generate the shower * for a hard process */ virtual bool deconstructHardJets(HardTreePtr,ShowerInteraction) const; //@} public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** * Methods to reconstruct the kinematics of individual jets */ //@{ /** * Given the particle (ShowerParticle object) that * originates a forward (time-like) jet, this method reconstructs the kinematics * of the jet. That is, by starting from the final grand-children (which * originates directly or indirectly from particleJetParent, * and which don't have children), and moving "backwards" (in a physical * time picture), towards the particleJetParent, the * ShowerKinematics objects associated with the various particles, * which have been created during the showering, are now completed. * In particular, at the end, we get the mass of the jet, which is the * main information we want. * This methods returns false if there was no radiation or rescaling required */ virtual bool reconstructTimeLikeJet(const tShowerParticlePtr particleJetParent) const; /** * Exactly similar to the previous one, but for a space-like jet. * Also in this case we start from the final grand-children (which * are childless) of the particle which originates the jet, but in * this case we proceed "forward" (in the physical time picture) * towards the particleJetParent. * This methods returns false if there was no radiation or rescaling required */ bool reconstructSpaceLikeJet(const tShowerParticlePtr particleJetParent) const; /** * Exactly similar to the previous one, but for a decay jet * This methods returns false if there was no radiation or rescaling required */ bool reconstructDecayJet(const tShowerParticlePtr particleJetParent) const; //@} /** * Methods to perform the reconstruction of various types of colour * singlet systems */ //@{ /** * Perform the reconstruction of a system with one incoming and at least one * outgoing particle */ void reconstructInitialFinalSystem(vector) const; /** * Perform the reconstruction of a system with only final-state * particles */ void reconstructFinalStateSystem(bool applyBoost, const LorentzRotation & toRest, const LorentzRotation & fromRest, vector) const; /** * Reconstruction of a general coloured system */ void reconstructGeneralSystem(vector & ShowerHardJets) const; /** * Reconstruction of a general coloured system doing * final-final, then initial-final and then initial-initial */ void reconstructFinalFirst(vector & ShowerHardJets) const; /** * Reconstruction of a general coloured system doing * colour parners */ void reconstructColourPartner(vector & ShowerHardJets) const; /** * Reconstruction based on colour singlet systems */ void reconstructColourSinglets(vector & ShowerHardJets, ShowerInteraction type) const; /** * Perform the reconstruction of a system with only final-state * particles */ void reconstructInitialInitialSystem(bool & applyBoost, LorentzRotation & toRest, LorentzRotation & fromRest, vector) const; //@} /** * Methods to perform the inverse reconstruction of various types of * colour singlet systems */ //@{ /** * Perform the inverse reconstruction of a system with only final-state * particles */ void deconstructFinalStateSystem(const LorentzRotation & toRest, const LorentzRotation & fromRest, HardTreePtr, vector, ShowerInteraction) const; /** * Perform the inverse reconstruction of a system with only initial-state * particles */ void deconstructInitialInitialSystem(bool & applyBoost, LorentzRotation & toRest, LorentzRotation & fromRest, HardTreePtr, vector, ShowerInteraction ) const; /** * Perform the inverse reconstruction of a system with only initial-state * particles */ void deconstructInitialFinalSystem(HardTreePtr, vector, ShowerInteraction ) const; bool deconstructGeneralSystem(HardTreePtr, ShowerInteraction) const; bool deconstructColourSinglets(HardTreePtr, ShowerInteraction) const; bool deconstructColourPartner(HardTreePtr, ShowerInteraction) const; //@} /** * Recursively treat the most off-shell paricle seperately * for final-final reconstruction */ void reconstructFinalFinalOffShell(JetKinVect orderedJets, Energy2 s, bool recursive) const; /** * Various methods for the Lorentz transforms needed to do the * rescalings */ //@{ /** * Compute the boost to get from the the old momentum to the new */ LorentzRotation solveBoost(const double k, const Lorentz5Momentum & newq, const Lorentz5Momentum & oldp) const; /** * Compute the boost to get from the the old momentum to the new */ LorentzRotation solveBoost(const Lorentz5Momentum & newq, const Lorentz5Momentum & oldq) const; /** * Compute the boost to get from the the old momentum to the new */ LorentzRotation solveBoostZ(const Lorentz5Momentum & newq, const Lorentz5Momentum & oldq) const; /** * Recursively boost the initial-state shower * @param p The particle * @param bv The boost * @param parent The parent of the chain */ void boostChain(tPPtr p, const LorentzRotation & bv, tPPtr & parent) const; /** * Given a 5-momentum and a scale factor, the method returns the * Lorentz boost that transforms the 3-vector vec{momentum} ---> * k*vec{momentum}. The method returns the null boost in the case no * solution exists. This will only work in the case where the * outgoing jet-momenta are parallel to the momenta of the particles * leaving the hard subprocess. */ Boost solveBoostBeta( const double k, const Lorentz5Momentum & newq, const Lorentz5Momentum & oldp); /** * Compute boost parameter along z axis to get (Ep, any perp, qp) * from (E, same perp, q). */ double getBeta(const double E, const double q, const double Ep, const double qp) const {return (q*E-qp*Ep)/(sqr(qp)+sqr(E));} //@} /** * Methods to calculate the various scaling factors */ //@{ /** * Given a vector of 5-momenta of jets, where the 3-momenta are the initial * ones before showering and the masses are reconstructed after the showering, * this method returns the overall scaling factor for the 3-momenta of the * vector of particles, vec{P}_i -> k * vec{P}_i, such to preserve energy- * momentum conservation, i.e. after the rescaling the center of mass 5-momentum * is equal to the one specified in input, cmMomentum. * The method returns 0 if such factor cannot be found. * @param root_s Centre-of-mass energy * @param jets The jets */ double solveKfactor( const Energy & root_s, const JetKinVect & jets ) const; /** * Calculate the rescaling factors for the jets in a particle decay where * there was initial-state radiation * @param mb The mass of the decaying particle * @param n The reference vector for the initial state radiation * @param pjet The momentum of the initial-state jet * @param jetKinematics The JetKinStruct objects for the jets * @param partner The colour partner * @param ppartner The momentum of the colour partner of the decaying particle * before and after radiation * @param k1 The rescaling parameter for the partner * @param k2 The rescaling parameter for the outgoing singlet * @param qt The transverse momentum vector */ bool solveDecayKFactor(Energy mb, const Lorentz5Momentum & n, const Lorentz5Momentum & pjet, const JetKinVect & jetKinematics, ShowerParticlePtr partner, Lorentz5Momentum ppartner[2], double & k1, double & k2, Lorentz5Momentum & qt) const; /** * Compute the momentum rescaling factor needed to invert the shower * @param pout The momenta of the outgoing particles * @param mon The on-shell masses * @param roots The mass of the decaying particle */ double inverseRescalingFactor(vector pout, vector mon,Energy roots) const; /** * Compute the momentum rescaling factor needed to invert the shower * @param pout The momenta of the outgoing particles * @param mon The on-shell masses * @param roots The mass of the decaying particle * @param ppartner The momentum of the colour partner * @param mbar The mass of the decaying particle * @param k1 The first scaling factor * @param k2 The second scaling factor */ bool inverseDecayRescalingFactor(vector pout, vector mon,Energy roots, Lorentz5Momentum ppartner, Energy mbar, double & k1, double & k2) const; /** * Check the rescaling conserves momentum * @param k The rescaling * @param root_s The centre-of-mass energy * @param jets The jets */ Energy momConsEq(double k, const Energy & root_s, const JetKinVect & jets) const; void findInitialBoost(const Lorentz5Momentum & pold, const Lorentz5Momentum & pnew, LorentzRotation & toRest, LorentzRotation & fromRest) const; //@} /** * Find the colour partners of a particle to identify the colour singlet * systems for the reconstruction. */ template void findPartners(Value branch,set & done, const set & branchings, vector & jets) const; /** * Add the intrinsic \f$p_T\f$ to the system if needed */ bool addIntrinsicPt(vector) const; /** * Apply a transform to the particle and any child, including child ShowerTree * objects * @param particle The particle * @param r The Lorentz transformation * @param match Whether or not to look at children etc * @param original The original particle */ void deepTransform(PPtr particle,const LorentzRotation & r, bool match=true,PPtr original=PPtr()) const; /** * Find the mass of a particle in the hard branching */ Energy findMass(HardBranchingPtr) const; /** * Calculate the initial-state rescaling factors */ vector initialStateRescaling(double x1, double x2, const Lorentz5Momentum & pold, const vector & p, const vector & pq, const vector& highespts) const; /** * Calculate the inverse of the initial-state rescaling factor */ vector inverseInitialStateRescaling(double & x1, double & x2, const Lorentz5Momentum & pold, const vector & p, const vector & pq) const; /** * Find the colour singlet systems */ template typename ColourSinglet::VecType identifySystems(set jets, unsigned int & nnun,unsigned int & nnii, unsigned int & nnif,unsigned int & nnf, unsigned int & nni) const; /** * Combine final-state colour systems */ template void combineFinalState(vector > & systems) const; protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const {return new_ptr(*this);} /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const {return new_ptr(*this);} //@} protected: /** @name Standard Interfaced functions. */ //@{ /** * Initialize this object after the setup phase before saving an * EventGenerator to disk. * @throws InitException if object could not be initialized properly. */ virtual void doinit(); //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - QTildeReconstructor & operator=(const QTildeReconstructor &); + QTildeReconstructor & operator=(const QTildeReconstructor &) = delete; private: /** * Option for handling the reconstruction */ unsigned int _reconopt; /** * Option for the boost for initial-initial reconstruction */ unsigned int _initialBoost; /** * Option for the reconstruction of final state systems */ unsigned int _finalStateReconOption; /** * Option for the initial state reconstruction */ unsigned int _initialStateReconOption; /** * Minimum invariant mass for initial-final dipoles to allow the * reconstruction */ Energy _minQ; /** * The progenitor of the jet currently being reconstructed */ mutable tShowerParticlePtr _progenitor; /** * Storage of the intrinsic \f$p_T\f$ */ mutable map > _intrinsic; /** * Current ShowerTree */ mutable tShowerTreePtr _currentTree; /** * Particles which shouldn't have their masses rescaled as * vector for the interface */ PDVector _noRescaleVector; /** * Particles which shouldn't have their masses rescaled as * set for quick access */ set _noRescale; /** * Storage of the boosts applied to enable resetting after failure */ mutable map > _boosts; /** * Storage of the boosts applied to enable resetting after failure */ mutable map > _treeBoosts; }; } #include "QTildeReconstructor.tcc" #endif /* HERWIG_QTildeReconstructor_H */ diff --git a/Shower/QTilde/Default/QTildeShowerKinematics1to2.h b/Shower/QTilde/Default/QTildeShowerKinematics1to2.h --- a/Shower/QTilde/Default/QTildeShowerKinematics1to2.h +++ b/Shower/QTilde/Default/QTildeShowerKinematics1to2.h @@ -1,132 +1,132 @@ // -*- C++ -*- // // QTildeShowerKinematics1to2.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_QTildeShowerKinematics1to2_H #define HERWIG_QTildeShowerKinematics1to2_H // // This is the declaration of the QTildeShowerKinematics1to2 class. // #include "Herwig/Shower/Core/Base/ShowerKinematics.h" #include "ThePEG/Vectors/Lorentz5Vector.h" #include "QTildeShowerKinematics1to2.fh" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * This abstract class describes the common features for initial and final * state radiation kinematics for \f$1\to2\f$ branchings and for * the choice of \f$\tilde{q}\f$ as evolution variable. * * @see ShowerKinematics * @see IS_QTildeShowerKinematics1to2 * @see FS_QTildeShowerKinematics1to2 * @see KinematicsReconstructor */ class QTildeShowerKinematics1to2: public ShowerKinematics { public: /** * Implementation of the virtual function returning a set of basis vectors, specific to * the type of evolution. This function will be used by the * ForwardShowerEvolver in order to access \f$p\f$ * and \f$n\f$. */ virtual vector getBasis() const; /** * Access to the \f$p\f$ vector used to describe the kinematics. */ const Lorentz5Momentum & pVector() const {return _pVector;} /** * Access to the \f$n\f$ vector used to describe the kinematics. */ const Lorentz5Momentum & nVector() const {return _nVector;} /** * Dot product of thew basis vectors */ Energy2 p_dot_n() const {return _pVector*_nVector;} /** * Converts a Sudakov parametrization of a momentum w.r.t. the given * basis \f$p\f$ and \f$n\f$ into a 5 momentum. * @param alpha The \f$\alpha\f$ parameter of the Sudakov parameterisation * @param beta The \f$\beta\f$ parameter of the Sudakov parameterisation * @param px The \f$x\f$-component of the transverse momentum in the Sudakov * parameterisation * @param py The \f$x\f$-component of the transverse momentum in the Sudakov * parameterisation */ Lorentz5Momentum sudakov2Momentum(double alpha, double beta, Energy px, Energy py) const { return alpha*_pVector + beta*_nVector + px*_xPerp+py*_yPerp; } /** * Transform the shower kinematics (usually the reference vectors) */ virtual void transform(const LorentzRotation & r); protected: /** * Set the basis vectors */ void setBasis(const Lorentz5Momentum &p, const Lorentz5Momentum & n, Frame frame); /** * Set a preliminary momentum for the particle */ void setMomentum(tShowerParticlePtr,bool timelike) const; /** * Construct the spin info object for a shower particle */ void constructSpinInfo(tShowerParticlePtr,bool timelike) const; private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - QTildeShowerKinematics1to2 & operator=(const QTildeShowerKinematics1to2 &); + QTildeShowerKinematics1to2 & operator=(const QTildeShowerKinematics1to2 &) = delete; private: /** * The \f$p\f$ reference vector */ Lorentz5Momentum _pVector; /** * The \f$n\f$ reference vector */ Lorentz5Momentum _nVector; /** * x \f$q_\perp\f$ reference vector */ LorentzVector _xPerp; /** * y \f$q_\perp\f$reference vector */ LorentzVector _yPerp; }; } #endif /* HERWIG_QTildeShowerKinematics1to2_H */ diff --git a/Shower/QTilde/Default/QTildeSudakov.h b/Shower/QTilde/Default/QTildeSudakov.h --- a/Shower/QTilde/Default/QTildeSudakov.h +++ b/Shower/QTilde/Default/QTildeSudakov.h @@ -1,291 +1,291 @@ // -*- C++ -*- // // QTildeSudakov.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_QTildeSudakov_H #define HERWIG_QTildeSudakov_H // // This is the declaration of the QTildeSudakov class. // #include "Herwig/Shower/Core/Base/SudakovFormFactor.h" namespace Herwig { using namespace ThePEG; /** \ingroup Shower * * The QTildeSudakov class implements the Sudakov form factor for evolution in * \f$\tilde{q}^2\f$ using the veto algorithm. * * @see \ref QTildeSudakovInterfaces "The interfaces" * defined for QTildeSudakov. */ class QTildeSudakov: public SudakovFormFactor { public: /** * The default constructor. */ inline QTildeSudakov() {} /** * Members to generate the scale of the next branching */ //@{ /** * Return the scale of the next time-like branching. If there is no * branching then it returns ZERO. * @param startingScale starting scale for the evolution * @param ids The PDG codes of the particles in the splitting * @param enhance The radiation enhancement factor * @param maxQ2 The maximum \f$Q^2\f$ for the emission */ virtual ShoKinPtr generateNextTimeBranching(const Energy startingScale, const IdList &ids, const RhoDMatrix & rho, double enhance, double detuning, Energy2 maxQ2); /** * Return the scale of the next space-like decay branching. If there is no * branching then it returns ZERO. * @param startingScale starting scale for the evolution * @param stoppingScale stopping scale for the evolution * @param minmass The minimum mass allowed for the spake-like particle. * @param ids The PDG codes of the particles in the splitting * defined. * @param enhance The radiation enhancement factor */ virtual ShoKinPtr generateNextDecayBranching(const Energy startingScale, const Energy stoppingScale, const Energy minmass, const IdList &ids, const RhoDMatrix & rho, double enhance, double detuning); /** * Return the scale of the next space-like branching. If there is no * branching then it returns ZERO. * @param startingScale starting scale for the evolution * @param ids The PDG codes of the particles in the splitting * @param x The fraction of the beam momentum * defined. * @param enhance The radiation enhancement factor * @param beam The beam particle */ virtual ShoKinPtr generateNextSpaceBranching(const Energy startingScale, const IdList &ids,double x, const RhoDMatrix & rho, double enhance, tcBeamPtr beam, double detuning); //@} /** * Generate the azimuthal angle of the branching for forward branching * @param particle The branching particle * @param ids The PDG codes of the particles in the branchings * @param The Shower kinematics */ virtual double generatePhiForward(ShowerParticle & particle,const IdList & ids, ShoKinPtr kinematics, const RhoDMatrix & rho); /** * Generate the azimuthal angle of the branching for backward branching * @param particle The branching particle * @param ids The PDG codes of the particles in the branchings * @param The Shower kinematics */ virtual double generatePhiBackward(ShowerParticle & particle,const IdList & ids, ShoKinPtr kinematics, const RhoDMatrix & rho); /** * Generate the azimuthal angle of the branching for ISR in decays * @param particle The branching particle * @param ids The PDG codes of the particles in the branchings * @param The Shower kinematics */ virtual double generatePhiDecay(ShowerParticle & particle,const IdList & ids, ShoKinPtr kinematics, const RhoDMatrix & rho); /** * Method to return the evolution scale given the * transverse momentum, \f$p_T\f$ and \f$z\f$. */ virtual Energy calculateScale(double z, Energy pt, IdList ids,unsigned int iopt); /** * Method to create the ShowerKinematics object for a final-state branching */ virtual ShoKinPtr createFinalStateBranching(Energy scale,double z, double phi, Energy pt); /** * Method to create the ShowerKinematics object for an initial-state branching */ virtual ShoKinPtr createInitialStateBranching(Energy scale,double z, double phi, Energy pt); /** * Method to create the ShowerKinematics object for a decay branching */ virtual ShoKinPtr createDecayBranching(Energy scale,double z, double phi, Energy pt); public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); protected: /** * Methods to provide the next value of the scale before the vetos * are applied. */ //@{ /** * Value of the energy fraction and scale for time-like branching * @param t The scale * @param tmin The minimum scale * @param enhance The radiation enhancement factor * @return False if scale less than minimum, true otherwise */ bool guessTimeLike(Energy2 &t, Energy2 tmin, double enhance, double detune); /** * Value of the energy fraction and scale for time-like branching * @param t The scale * @param tmax The maximum scale * @param minmass The minimum mass of the particle after the branching * @param enhance The radiation enhancement factor */ bool guessDecay(Energy2 &t, Energy2 tmax,Energy minmass, double enhance, double detune); /** * Value of the energy fraction and scale for space-like branching * @param t The scale * @param tmin The minimum scale * @param x Fraction of the beam momentum. * @param enhance The radiation enhancement factor */ bool guessSpaceLike(Energy2 &t, Energy2 tmin, const double x, double enhance, double detune); //@} /** * Initialize the values of the cut-offs and scales * @param tmin The minimum scale * @param ids The ids of the partics in the branching */ void initialize(const IdList & ids,Energy2 &tmin); /** * Phase Space veto member to implement the \f$\Theta\f$ function as a veto * so that the emission is within the allowed phase space. * @param t The scale * @param maxQ2 The maximum virtuality * @return true if vetoed */ bool PSVeto(const Energy2 t,const Energy2 maxQ2); /** * Compute the limits on \f$z\f$ for time-like branching * @param scale The scale of the particle * @return True if lower limit less than upper, otherwise false */ bool computeTimeLikeLimits(Energy2 & scale); /** * Compute the limits on \f$z\f$ for space-like branching * @param scale The scale of the particle * @param x The energy fraction of the parton * @return True if lower limit less than upper, otherwise false */ bool computeSpaceLikeLimits(Energy2 & scale, double x); protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ inline virtual IBPtr clone() const {return new_ptr(*this);} /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ inline virtual IBPtr fullclone() const {return new_ptr(*this);} //@} private: /** * The assignment operator is private and must never be called. * In fact, it should not even be implemented. */ - QTildeSudakov & operator=(const QTildeSudakov &); + QTildeSudakov & operator=(const QTildeSudakov &) = delete; private: /** * The evolution scale, \f$\tilde{q}\f$. */ Energy q_; /** * The Ids of the particles in the current branching */ IdList ids_; /** * The masses of the particles in the current branching */ vector masses_; /** * The mass squared of the particles in the current branching */ vector masssquared_; }; } #endif /* HERWIG_QTildeSudakov_H */ diff --git a/Tests/DIS/DISTest.h b/Tests/DIS/DISTest.h old mode 100755 new mode 100644 diff --git a/Tests/Gamma/GammaMETest.h b/Tests/Gamma/GammaMETest.h old mode 100755 new mode 100644 diff --git a/Tests/Gamma/GammaPMETest.h b/Tests/Gamma/GammaPMETest.h old mode 100755 new mode 100644 diff --git a/Tests/Hadron/HadronVBFTest.h b/Tests/Hadron/HadronVBFTest.h old mode 100755 new mode 100644 diff --git a/Tests/Hadron/HadronVVTest.h b/Tests/Hadron/HadronVVTest.h old mode 100755 new mode 100644 diff --git a/Tests/Lepton/VBFTest.h b/Tests/Lepton/VBFTest.h old mode 100755 new mode 100644 diff --git a/UnderlyingEvent/UA5Handler.h b/UnderlyingEvent/UA5Handler.h --- a/UnderlyingEvent/UA5Handler.h +++ b/UnderlyingEvent/UA5Handler.h @@ -1,472 +1,472 @@ // -*- C++ -*- // // UA5Handler.h is a part of Herwig - A multi-purpose Monte Carlo event generator // Copyright (C) 2002-2017 The Herwig Collaboration // // Herwig is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // #ifndef HERWIG_UA5_H_ #define HERWIG_UA5_H_ #include #include "Herwig/Hadronization/CluHadConfig.h" #include namespace Herwig { using namespace ThePEG; /** \ingroup UnderlyingEvent * * This is the class definition for the UA5Handler. This * class is designed to generate an underlying event * based on the UA5 model. This is intended as a basic * underlying event model which will be superceded by a * new model in Herwig. * * This class interfaces with * the cluster hadronization. To that end there is an * interface set up with the ClusterFissioner class and * with the ClusterDecayer class. * * The Hadronization is responsible * for the formation of the beam clusters. In this step the colour connection * between the spectators and the initial-state parton showers is cut by the * forced emission of a soft quark-antiquark pair. The underlying soft event in a * hard hadron-hadron collision is then assumed to be a soft collision * between these two beam clusters. * * The model used for the underlying event is based on the minimum-bias * \f$p\bar{p}\f$ event generator of the UA5 Collaboration, * UA5 Collaboration, G.J. Alner et al., Nucl. Phys. B291 (1987) 445, * modified to make use of our cluster fragmentation algorithm. * * The parameter ProbSoft enables one to produce an underlying event in * only a fraction ProbSoft of events (default=1.0). * * The UA5 model starts from a parametrization of the \f$p\bar{p}\f$ * inelastic charged multiplicity distribution as a negative binomial distribution, * \f[P(n) = \frac{\Gamma(n+k)}{n!\,\Gamma(k)} * \frac{(\bar n/k)^n}{(1+\bar n/k)^{n+k}}\;.\f] * The parameter \f$k\f$ is given by * \f[1/k =k_1\ln s+k_2,\f] * and \f$\bar n\f$ is given by * \f[\bar n =n_1s^{n_2}+n_3\f] * As an option, for underlying events the value of \f$\sqrt{s}\f$ used to choose * the multiplicity \f$n\f$ may be increased by a factor EnhanceCM to allow * for an enhanced underlying activity in hard events. * * Once a charged multiplicity has been selected from the above distribution, * `softclusters' are generated with flavours \f$(f_1,f_2) = (q_{n-1},\bar q_n)\f$ * by drawing \f$q_n\bar q_n = u\bar u$ or $d\bar d\f$ randomly from the * vacuum. Soft cluster masses are assigned as * \f[M = m_{q1}+m_{q2}+m_1-\log(r_1 r_2)/m_2 \f] * where \f$r_{1,2}\f$ are random numbers, which gives a (shifted) exponential * distribution of \f$M^2\f$. The parameters \f$m_1\f$ and \f$m_2\f$ control * the distribution and \f$m_{q1,2}\f$ are the masses of the quarks in the cluster. * * As each soft cluster is generated, it is decayed to stable hadrons using * the cluster hadronization model (without cluster fission) and the accumulated * charged multiplicity is computed. * Once the preselected charged multiplicity is exactly reached, * cluster generation is stopped. If it is exceeded, all clusters are rejected * and new ones are generated until the exact value is reached. In this way the * multiplicity distribution of stable charged hadrons * is generated exactly as prescribed. * * At this stage (to save time) the kinematic distribution of the soft clusters * has not yet been generated. The decay products of each cluster are stored * in its rest frame. Now the transverse momenta of the clusters are * generated with the distribution * \f[P(p_t)\propto p_t\exp\left(-p_{1,2,3}\sqrt{p_t^2+M^2}\right)\f] * where the slope parameter \f$p_{1,2,3}\f$ depends as indicated on the * flavour of the quark or diquark pair created in the * primary cluster decay, \f$p_1\f$ for light quarks, \f$p_2\f$ for the strange and * charm quarks and \f$p_3\f$ for diquarks. * Next the clusters are given a flat * rapidity distribution with Gaussian shoulders. The `reduced * rapidities' \f$\xi_i\f$ are generated first by drawing * from a distribution * \f[P(\xi) = N\;\;\;\mbox{for}\;|\xi|<0.6\f] * \f[P(\xi) = N\,e^{-(\xi-0.6)^2/2} \;\;\;\mbox{for}\;\xi>0.6\f] * \f[P(\xi) = N\,e^{-(\xi+0.6)^2/2} \;\;\;\mbox{for}\;\xi<-0.6\f] * where \f$N=1/(1.2+\sqrt{2\pi})\f$ is the normalization. Next * a scaling factor \f$Y\f$ is computed such that the scaled cluster * rapidities \f$y_i=Y\xi_i\f$, their masses and transverse momenta * satisfy momentum conservation when compared to the total * energy of the underlying event. Thus the soft cluster rapidity * distribution retains its overall shape but becomes higher and * wider as the energy of the underlying event increases. * * Finally the decay products of each cluster are boosted from * its rest frame into the lab frame and added to the event record. * * @see \ref UA5HandlerInterfaces "The interfaces" * defined for UA5Handler.. */ class UA5Handler : public HadronizationHandler { public: /** @name Standard constructors and destructors. */ //@{ /** * The default constructor. */ UA5Handler(); //@} /** * The standard Init function used to initialize the interfaces. * Called exactly once for each class by the class description system * before the main function starts or * when this class is dynamically loaded. */ static void Init(); public: /** @name Functions used by the persistent I/O system. */ //@{ /** * Function used to write out object persistently. * @param os the persistent output stream written to. */ void persistentOutput(PersistentOStream & os) const; /** * Function used to read in object persistently. * @param is the persistent input stream read from. * @param version the version number of the object when written. */ void persistentInput(PersistentIStream & is, int version); //@} public: /** * This is the routine that starts the algorithm. * @param eh the EventHandler in charge of the generation. * @param tagged the vector of particles to consider. If empty, all * final state particles in the current Step is considered. * @param hint a possible Hint which is ignored in this implementation */ virtual void handle(EventHandler &eh, const tPVector &tagged, const Hint &hint) ; protected: /** @name Clone Methods. */ //@{ /** * Make a simple clone of this object. * @return a pointer to the new object. */ virtual IBPtr clone() const; /** Make a clone of this object, possibly modifying the cloned object * to make it sane. * @return a pointer to the new object. */ virtual IBPtr fullclone() const; //@} private: /** * Members to decay the clusters and hadrons produced in their decay, * and insert the output in the event record. */ //@{ /** * Perform the decay of an unstable hadron. * @param parent the decaying particle * @param totalcharge The totalcharge of the decay proiducts * @param numbercharge The number of stabel charged decay products */ void performDecay(PPtr parent,int & totalcharge,int & numbercharge) const; /** * Decay a cluster to two hadrons is sufficiently massive and to one if * not. * @param cluster The cluster to decay * @param single Whether or not ot allow decays to */ void decayCluster(ClusterPtr cluster, bool single) const; /** * Recursively add particle and decay products to the step * @param particle The particle * @param step The step * @param all Insert this particle as well as children */ void insertParticle(PPtr particle,StepPtr step,bool all) const; //@} /** * Members to generate the multiplicity according to a negative binomial * distribution. */ //@{ /** * Calculate the negative binomial probability given the * mean \f$\bar n\f$, the multiplicity and \f$1/k\f$. * @param N The multplicity for which to calculate the probability * @param mean The mean multiplicity \f$\bar n\f$ * @param ek \f$1/k\f$ * @return a value distributed according the negative binomial distribution */ inline double negativeBinomial(int N, double mean, double ek) const; /** * The value of the mean multiplicity for a given energy E. * This is \f$n_1E^{2n_2}+n_3\f$ wher \f$n_1\f$, \f$n_2\f$ and \f$n_3\f$ * are parameters. * @param E the energy to calculate the mean multiplicity for * @return the mean multiplicity */ inline double meanMultiplicity(Energy E) const; /** * Generates a multiplicity for the energy E according to the negative * binomial distribution. * @param E The energy to generate for * @return the randomly generated multiplicity for the energy given */ unsigned int multiplicity(Energy E) const; //@} /** * Members to generate the momenta of the clusters */ //@{ /** * This generates the momentum of the produced particles according to * the cylindrical phase space algorithm given * in Computer Physics Communications 9 (1975) 297-304 by S. Jadach. * @param clu1 The first incoming cluster * @param clu2 The second incoming cluster * @param clusters The list of clusters produced * @param CME The center of mass energy * @param cm The center of mass momentum (of the underlying event) */ void generateMomentum(tClusterPtr clu1,tClusterPtr clu2, const ClusterVector &clusters, Energy CME, const Lorentz5Momentum & cm) const; /** * The implementation of the cylindrical phase space. * @param clusters The list of clusters to generate the momentum for * @param CME The center of mass energy */ void generateCylindricalPS(const ClusterVector &clusters, Energy CME) const; //@} /** * This returns the rotation matrix needed to rotate p into the z axis */ LorentzRotation rotate(const LorentzMomentum &p) const; /** * Various methods to generate random distributions */ //@{ /** * Gaussian distribution * @param mean the mean of the distribution * @param stdev the standard deviation of the distribution * @return Arandom value from the gaussian distribution */ template inline T gaussDistribution(T mean, T stdev) const; /** * This returns a random number with a flat distribution * [-A,A] plus gaussian tail with stdev B * TODO: Should move this to Utilities * @param A The width of the flat part * @param B The standard deviation of the gaussian tail * @return the randomly generated value */ inline double randUng(double A, double B) const; /** * Generates a random azimuthal angle and puts x onto px and py * TODO: Should move this to Utilities * @param pt The magnitude of the transverse momentum * @param px The x component after random rotation * @param py The y component after random rotation */ template inline void randAzm(T pt, T &px, T &py) const; /** * This returns random number from \f$dN/dp_T^2=exp(-p_{1,2,3}m_T\f$ distribution, * where \f$m_T=\sqrt{p_T^2+M^2}\f$. It uses Newton's method to solve \f$F-R=0\f$ * @param AM0 The mass \f$M\f$. * @param B The slope * @return the value distributed from \f$dN/dp_T^2=exp(-p_{1,2,3}m_T\f$ with mean av */ inline Energy randExt(Energy AM0,InvEnergy B) const; //@} private: /** * The static object used to initialize the description of this class. * Indicates that this is a concrete class with persistent data. */ static ClassDescription initUA5Handler; /** * This is never defined and since it can never be called it isn't * needed. The prototype is defined so the compiler doesn't use the * default = operator. */ - UA5Handler& operator=(const UA5Handler &); + UA5Handler& operator=(const UA5Handler &) = delete; private: /** * Reference to the ClusterFissioner object */ ClusterFissionerPtr clusterFissioner; /** * Reference to the cluster decayer object. */ ClusterDecayerPtr clusterDecayer; /** * Parameters for the mean multiplicity \f$\bar n =n_1s^{n_2}+n_3\f$ */ //@{ /** * The parameter \f$n_1\f$ */ double _n1; /** * The parameter \f$n_2\f$ */ double _n2; /** * The parameter \f$n_3\f$ */ double _n3; //@} /** * Parameters for \f$k\f$ in the negative binomial * distribution given by \f$1/k =k_1\ln s+k_2\f$ */ //@{ /** * The parameter \f$k_1\f$ */ double _k1; /** * The parameter \f$k_2\f$ */ double _k2; //@} /** * Parameters for the cluster mass distribution, * \f$M = m_{q1}+m_{q2}+m_1-\log(r_1 r_2)/m_2\f$. */ //@{ /** * The parameter \f$m_1\f$ */ Energy _m1; /** * The parameter \f$m_2\f$ */ InvEnergy _m2; //@} /** * Parameters for the transverpse momentum of the soft distribution, * \f$P(p_T) \propto p_T*exp(-p_i\sqrt{p_T^2+M^2}\f$ */ //@{ /** * The parameter \f$p_1\f$ for light quarks */ InvEnergy _p1; /** * The parameter \f$p_2\f$ for strange and charm quarks */ InvEnergy _p2; /** * The parameter \f$p_3\f$ for diquarks */ InvEnergy _p3; //@} /** * This is the probability of having a soft underlying event. */ double _probSoft; /** * This is a parameter used to enhance the CM energy used to * generate the multiplicity distribution. */ double _enhanceCM; /** * The maximum number of attempts to generate the distribution */ unsigned int _maxtries; /** * Whether to warn about using UA5 and MPI simultaneously. */ bool _needWarning; }; } namespace ThePEG { /** @cond TRAITSPECIALIZATIONS */ /** This template specialization informs ThePEG about the * base classes of UA5Handler. */ template<> struct BaseClassTrait { /** Typedef of the first base class of UA5Handler. */ typedef HadronizationHandler NthBase; }; /** This template specialization informs ThePEG about the name of * the UA5Handler class and the shared object where it is defined. */ template<> struct ClassTraits : public ClassTraitsBase { /** Return a platform-independent class name */ static string className() { return "Herwig::UA5Handler"; } /** Return the name of the shared library be loaded to get * access to the WeakPartonicDecayer class and every other class it uses * (except the base class). */ static string library() { return "HwUA5.so"; } }; /** @endcond */ } #include "UA5Handler.icc" #endif