Matchbox/Phasespace/FFMassiveInvertedTildeKinematics.h

0001 // -*- C++ -*-
0002 //
0003 // FFMassiveInvertedTildeKinematics.h is a part of Herwig - A multi-purpose Monte Carlo event generator
0004 // Copyright (C) 2002-2019 The Herwig Collaboration
0005 //
0006 // Herwig is licenced under version 3 of the GPL, see COPYING for details.
0007 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
0008 //
0009 #ifndef HERWIG_FFMassiveInvertedTildeKinematics_H
0010 #define HERWIG_FFMassiveInvertedTildeKinematics_H
0011 //
0012 // This is the declaration of the FFMassiveInvertedTildeKinematics class.
0013 //
0014
0015 #include "Herwig/MatrixElement/Matchbox/Phasespace/InvertedTildeKinematics.h"
0016
0017 namespace Herwig {
0018
0019 using namespace ThePEG;
0020
0021 /**
0022  * \ingroup Matchbox
0023  * \author Simon Platzer, Stephen Webster
0024  *
0025  * \brief FFMassiveInvertedTildeKinematics inverts the final-final tilde
0026  * kinematics.
0027  *
0028  */
0029 class FFMassiveInvertedTildeKinematics: public Herwig::InvertedTildeKinematics {
0030
0031 public:
0032
0033   /**
0034    * Perform the mapping of the tilde kinematics for the
0035    * last selected process and store all dimensionless
0036    * variables in the subtractionParameters() vector.
0037    * Return false, if the calculation of the real
0038    * kinematics was impossible for the selected configuration
0039    * and true on success.
0040    */
0041   virtual bool doMap(const double *);
0042
0043   /**
0044    * Return the pt associated to the last generated splitting.
0045    */
0046   virtual Energy lastPt() const;
0047
0048   /**
0049    * Return the momentum fraction associated to the last splitting.
0050    */
0051   virtual double lastZ() const;
0052
0053   /**
0054    * Return the upper bound on pt
0055    */
0056   virtual Energy ptMax() const;
0057
0058   /**
0059    * Given a pt, return the boundaries on z
0060    * Note that allowing parton masses these bounds may be too loose
0061    */
0062   virtual pair<double,double> zBounds(Energy pt, Energy hardPt = ZERO) const;
0063
0064   /**
0065    * For generated pt and z, check if this point is
0066    * kinematically allowed
0067    */
0068   /*virtual*/ bool ptzAllowed(pair<Energy,double> ptz, vector<double>* values ) const;
0069
0070   /**
0071    * Generate pt and z
0072    */
0073   virtual pair<Energy,double> generatePtZ(double& jac, const double * r, vector<double>* values) const;
0074
0075 public:
0076
0077   /**
0078    * Triangular / Kallen function
0079    */
0080   template <class T>
0081   inline T rootOfKallen (T a, T b, T c) const {
0082     return sqrt( a*a + b*b + c*c - 2.*( a*b+a*c+b*c ) ); }
0083
0084   // TODO: remove in both
0085   /**
0086    * stolen from FFMassiveKinematics.h
0087    * Perform a rotation on both momenta such that the first one will
0088    * point along the (positive) z axis. Rotate back to the original
0089    * reference frame by applying rotateUz(returnedVector) to each momentum.
0090    */
0091   ThreeVector<double> rotateToZ (Lorentz5Momentum& pTarget, Lorentz5Momentum& p1) {
0092     ThreeVector<double> oldAxis = pTarget.vect().unit();
0093     double ct = oldAxis.z(); double st = sqrt( 1.-sqr(ct) ); // cos,sin(theta)
0094     double cp = oldAxis.x()/st; double sp = oldAxis.y()/st; // cos,sin(phi)
0095     pTarget.setZ( pTarget.vect().mag() ); pTarget.setX( 0.*GeV ); pTarget.setY( 0.*GeV );
0096     Lorentz5Momentum p1old = p1;
0097     p1.setX(    sp*p1old.x() -    cp*p1old.y()                );
0098     p1.setY( ct*cp*p1old.x() + ct*sp*p1old.y() - st*p1old.z() );
0099     p1.setZ( st*cp*p1old.x() + st*sp*p1old.y() + ct*p1old.z() );
0100     return oldAxis;
0101   }
0102
0103 public:
0104
0105   /** @name Functions used by the persistent I/O system. */
0106   //@{
0107   /**
0108    * Function used to write out object persistently.
0109    * @param os the persistent output stream written to.
0110    */
0111   void persistentOutput(PersistentOStream & os) const;
0112
0113   /**
0114    * Function used to read in object persistently.
0115    * @param is the persistent input stream read from.
0116    * @param version the version number of the object when written.
0117    */
0118   void persistentInput(PersistentIStream & is, int version);
0119   //@}
0120
0121   /**
0122    * The standard Init function used to initialize the interfaces.
0123    * Called exactly once for each class by the class description system
0124    * before the main function starts or
0125    * when this class is dynamically loaded.
0126    */
0127   static void Init();
0128
0129 protected:
0130
0131   /** @name Clone Methods. */
0132   //@{
0133   /**
0134    * Make a simple clone of this object.
0135    * @return a pointer to the new object.
0136    */
0137   virtual IBPtr clone() const;
0138
0139   /** Make a clone of this object, possibly modifying the cloned object
0140    * to make it sane.
0141    * @return a pointer to the new object.
0142    */
0143   virtual IBPtr fullclone() const;
0144   //@}
0145
0146
0147 // If needed, insert declarations of virtual function defined in the
0148 // InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
0149
0150
0151 private:
0152
0153   /**
0154    * The assignment operator is private and must never be called.
0155    * In fact, it should not even be implemented.
0156    */
0157   FFMassiveInvertedTildeKinematics & operator=(const FFMassiveInvertedTildeKinematics &) = delete;
0158
0159
0160 };
0161
0162 }
0163
0164 #endif /* HERWIG_FFMassiveInvertedTildeKinematics_H */