Helicity/WaveFunction/VectorWaveFunction.h

0001 // -*- C++ -*-
0002 //
0003 // VectorWaveFunction.h is a part of ThePEG - Toolkit for HEP Event Generation
0004 // Copyright (C) 2003-2019 Peter Richardson, Leif Lonnblad
0005 //
0006 // ThePEG 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 ThePEG_VectorWaveFunction_H
0010 #define ThePEG_VectorWaveFunction_H
0011 //
0012 // This is the declaration of the VectorWaveFunction class.
0013 //
0014 #include "WaveFunctionBase.h"
0015 #include <ThePEG/Helicity/LorentzPolarizationVector.h>
0016 #include <ThePEG/Helicity/VectorSpinInfo.h>
0017 #include <ThePEG/EventRecord/RhoDMatrix.h>
0018 #include <ThePEG/EventRecord/Particle.h>
0019
0020 namespace ThePEG {
0021 namespace Helicity {
0022
0023 /** \ingroup Helicity
0024  *
0025  *  \author Peter Richardson
0026  *
0027  *  The VectorWaveFunction class is designed to store the wavefunction
0028  *  of a vector in a form suitable for use in helicity amplitude calculations
0029  *  of the matrix element using a similar philosophy to the FORTRAN HELAS code.
0030  *
0031  *  In addition to storing the vector using the LorentzPolarizationVector class
0032  *  it inherits from the WaveFunctionBase class to provide storage of the
0033  *  momentum and ParticleData for the vector boson.
0034  *
0035  *  This class also contains the code which does the actually calculation of the
0036  *  vector wavefunction.
0037  *
0038  *  There are two choices available for the calculation of the wavefunction.
0039  *  These are set using the VectorPhase enumeration which specifies a default choice.
0040  *  The first choice, vector_phase, includes a phase factor \f$\exp(\pm i \phi)\f$
0041  *  for the \f$\pm\f$ helicity states while the second, vector_nophase, does not.
0042  *
0043  *  N.B. In our convention 0 is the \f$-1\f$ helicity state and
0044  *        1 is the \f$0\f$ helicity state
0045  *        2 is the \f$+1\f$ helicity state
0046  *
0047  *  @see WaveFunctionBase
0048  *  @see LorentzPolarizationVector
0049  */
0050 class VectorWaveFunction : public WaveFunctionBase {
0051
0052 public:
0053
0054   /** @name Standard constructors and destructors. */
0055   //@{
0056   /**
0057    * Constructor, set the momentum and Wavefunction, the direction can also
0058    * be specified.
0059    * @param p The momentum.
0060    * @param part The ParticleData pointer
0061    * @param wave The wavefunction, \e i.e. the polarization vector.
0062    * @param dir The direction of the particle.
0063    */
0064   VectorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
0065              const LorentzPolarizationVector & wave,
0066              Direction  dir=intermediate)
0067     : WaveFunctionBase(p,part,dir), _wf(wave)
0068   {
0069     assert(iSpin()==3);
0070   }
0071
0072   /**
0073    * Constructor, set the momentum and components of the wavefunction.
0074    * @param p The momentum.
0075    * @param part The ParticleData pointer
0076    * @param x The x component of the polarization vector
0077    * @param y The y component of the polarization vector
0078    * @param z The z component of the polarization vector
0079    * @param t The t component of the polarization vector
0080    */
0081   VectorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,const Complex & x,
0082              const Complex & y,const Complex & z, const Complex & t)
0083     : WaveFunctionBase(p,part), _wf(x,y,z,t)
0084   {
0085     assert(iSpin()==3);
0086   }
0087
0088   /**
0089    * Constructor, set the momentum, helicity and direction, optionally the choice
0090    * of the phase.
0091    * @param p The momentum.
0092    * @param part The ParticleData pointer.
0093    * @param ihel The helicity (0,1,2 as described above.)
0094    * @param dir The direction.
0095    * @param phase The phase choice.
0096    */
0097   VectorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
0098              unsigned int ihel,Direction dir,
0099              VectorPhase phase=default_vector_phase)
0100     : WaveFunctionBase(p,part,dir)
0101   {
0102     assert(iSpin()==3);
0103     calculateWaveFunction(ihel,phase);
0104   }
0105
0106   /**
0107    * Constructor, set the 5-momentum and direction, zero the wavefunction.
0108    * @param p The 5-momentum.
0109    * @param part The ParticleData pointer.
0110    * @param dir The direction.
0111    */
0112   VectorWaveFunction(const Lorentz5Momentum &p,
0113              tcPDPtr part,Direction dir)
0114     : WaveFunctionBase(p,part,dir), _wf()
0115   {
0116     assert(iSpin()==3);
0117   }
0118
0119   /**
0120    * Default constructor.
0121    */
0122   VectorWaveFunction() {}
0123
0124   /**
0125    *  Special for spin correlations \todo make static?
0126    */
0127   VectorWaveFunction(vector<VectorWaveFunction> & wave,
0128              tPPtr part,Direction dir,bool time,bool massless,
0129              bool=true,
0130              VectorPhase phase=default_vector_phase) {
0131     calculateWaveFunctions(wave,part,dir,massless,phase);
0132     constructSpinInfo(wave,part,dir,time,massless);
0133   }
0134   //@}
0135
0136   /**
0137    *  Access to the wavefunction and its components.
0138    */
0139   //@{
0140   /**
0141    * Return wavefunction as polarization vector.
0142    */
0143   const LorentzPolarizationVector & wave() const { return _wf;}
0144
0145   /**
0146    * Get x component.
0147    */
0148   Complex x() const {return _wf.x();}
0149
0150   /**
0151    * Get y component.
0152    */
0153   Complex y() const {return _wf.y();}
0154
0155   /**
0156    * Get z component.
0157    */
0158   Complex z() const {return _wf.z();}
0159
0160   /**
0161    * Get t component.
0162    */
0163   Complex t() const {return _wf.t();}
0164
0165   /**
0166    * Reset functions.
0167    */
0168   //@{
0169   /**
0170    * Reset the helicity (recalculation the polarization vector).
0171    * @param ihel The new helicity (0,1,2 as described above.)
0172    * @param phase The phase choice.
0173    */
0174   void reset(unsigned int ihel,VectorPhase phase=default_vector_phase) {
0175     calculateWaveFunction(ihel,phase);
0176   }
0177   //@}
0178
0179 public:
0180
0181   /**
0182    *  Perform the Lorentz transformation of the wave function
0183    */
0184   void transform(const LorentzRotation & r) {
0185     _wf.transform(r);
0186     transformMomentum(r);
0187   }
0188
0189 public:
0190
0191   /**
0192    *  Calculate the wavefunctions
0193    */
0194   static void calculateWaveFunctions(vector<LorentzPolarizationVector> & waves,
0195                      tPPtr particle,Direction,bool massless,
0196                      VectorPhase phase=default_vector_phase);
0197
0198   /**
0199    *  Calculate the wavefunctions
0200    */
0201   static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
0202                      tPPtr particle,Direction,bool massless,
0203                      VectorPhase phase=default_vector_phase);
0204
0205   /**
0206    *  Calculate the wavefunctions
0207    */
0208   static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
0209                      const Lorentz5Momentum & momentum,
0210                      tcPDPtr parton, Direction,bool massless,
0211                      VectorPhase phase=default_vector_phase);
0212
0213   /**
0214    *  Calculate the wavefunctions
0215    */
0216   static void calculateWaveFunctions(vector<LorentzPolarizationVector> & waves,
0217                      RhoDMatrix & rho,
0218                      tPPtr particle,Direction,bool massless,
0219                      VectorPhase phase=default_vector_phase);
0220
0221   /**
0222    *  Calculate the wavefunctions
0223    */
0224   static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
0225                      RhoDMatrix & rho,
0226                      tPPtr particle,Direction,bool massless,
0227                      VectorPhase phase=default_vector_phase);
0228
0229   /**
0230    *  Construct the SpinInfo object
0231    */
0232   static void constructSpinInfo(const vector<LorentzPolarizationVector> & waves,
0233                 tPPtr part,Direction dir, bool time,bool massless);
0234
0235   /**
0236    *  Construct the SpinInfo object
0237    */
0238   static void constructSpinInfo(const vector<VectorWaveFunction> & waves,
0239                 tPPtr part,Direction dir, bool time,bool massless);
0240
0241 private:
0242
0243   /**
0244    * Calculate the wavefunction
0245    * @param ihel The helicity  (0,1,2 as described above.)
0246    * @param phase The phase choice.
0247    */
0248   void calculateWaveFunction(unsigned int ihel,
0249                  VectorPhase phase=default_vector_phase);
0250
0251 private:
0252
0253   /**
0254    * Storage of the wavefunction as a Lorentz Vector.
0255    */
0256   LorentzPolarizationVector _wf;
0257
0258 };
0259
0260 }
0261 }
0262
0263 #endif