Helicity/WaveFunction/Rank3TensorWaveFunction.h

0001 // -*- C++ -*-
0002 //
0003 // Rank3TensorWaveFunction.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_Rank3TensorWaveFunction_H
0010 #define ThePEG_Rank3TensorWaveFunction_H
0011 //
0012 // This is the declaration of the Rank3TensorWaveFunction class.
0013 //
0014 #include "WaveFunctionBase.h"
0015 #include "VectorWaveFunction.h"
0016 #include <ThePEG/Helicity/LorentzRank3Tensor.h>
0017 #include <ThePEG/Helicity/Rank3TensorSpinInfo.h>
0018 #include <ThePEG/EventRecord/Particle.h>
0019 #include <ThePEG/EventRecord/RhoDMatrix.h>
0020
0021 namespace ThePEG {
0022 namespace Helicity {
0023
0024 /** \ingroup Helicity
0025  *  \author Peter Richardson
0026  *
0027  *  The Rank3TensorWaveFunction class is designed to store the wavefunction
0028  *  of a tensor in a form suitable for use in helicity amplitude
0029  *  calculations of the matrix element using a similar philosophy to the
0030  *  FORTRAN HELAS code.
0031  *
0032  *  In addition to storing the tensor using the LorentzRank3Tensor class
0033  *  it inherits from the WaveFunctionBase class to provide storage of
0034  *  the momentum and ParticleData for the tensor particle.
0035  *
0036  *  This class also contains the code which does the actually
0037  *  calculation of the tensor wavefunction.
0038  *
0039  *  N.B. In our convention
0040  *        0 is the \f$-3\f$ helicity state,
0041  *        1 is the \f$-2\f$ helicity state,
0042  *        2 is the \f$-1\f$ helicity state,
0043  *        3 is the \f$ 0\f$ helicity state,
0044  *        4 is the \f$+1\f$ helicity state and
0045  *        5 is the \f$+2\f$ helicity state.
0046  *        6 is the \f$+3\f$ helicity state.
0047  *
0048  *  @see WaveFunctionBase
0049  *  @see LorentzRank3Tensor
0050  *  @see VectorWaveFunction
0051  */
0052 class Rank3TensorWaveFunction : public WaveFunctionBase {
0053
0054 public:
0055
0056   /** @name Standard constructors and destructors. */
0057   //@{
0058   /**
0059    * Constructor, set the momentum and Wavefunction, the direction can also
0060    * be specified.
0061    * @param p The momentum.
0062    * @param part The ParticleData pointer
0063    * @param wave The wavefunction, \e i.e. the polarization vector.
0064    * @param dir The direction of the particle.
0065    */
0066   Rank3TensorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
0067               const LorentzRank3Tensor<double> & wave,
0068               Direction  dir=intermediate)
0069     : WaveFunctionBase(p,part,dir), _wf(wave) {
0070     assert(iSpin()==PDT::Spin3);
0071   }
0072
0073   /**
0074    * Constructor, set the momentum, helicity, direction and optionally the phase
0075    * @param p The momentum.
0076    * @param part The ParticleData pointer
0077    * @param ihel The helicity (0,1,2,3,4 as described above.)
0078    * @param dir The direction.
0079    * @param phase The phase choice.
0080    */
0081   Rank3TensorWaveFunction(const Lorentz5Momentum & p,tcPDPtr part,
0082               unsigned int ihel,Direction dir)
0083     : WaveFunctionBase(p,part,dir) {
0084     assert(iSpin()==PDT::Spin3);
0085     calculateWaveFunction(ihel);
0086   }
0087
0088   /**
0089    * Constructor, set the 5-momentum and direction, zero the wavefunction.
0090    * @param p The momentum.
0091    * @param part The ParticleData pointer.
0092    * @param dir The direction.
0093    */
0094   Rank3TensorWaveFunction(const Lorentz5Momentum & p,
0095               tcPDPtr part,Direction dir)
0096     : WaveFunctionBase(p,part,dir), _wf() {
0097     assert(iSpin()==PDT::Spin3);
0098   }
0099
0100   /**
0101    * Default constructor.
0102    */
0103   Rank3TensorWaveFunction() {}
0104
0105   /**
0106    *  Special for spin correlations \todo make static?
0107    */
0108   Rank3TensorWaveFunction(vector<Rank3TensorWaveFunction> & wave,
0109               tPPtr part,Direction dir,bool time,bool massless,
0110               bool=true) {
0111     calculateWaveFunctions(wave,part,dir,massless);
0112     constructSpinInfo(wave,part,dir,time,massless);
0113   }
0114   //@}
0115
0116   /**
0117    *  Access to the wavefunction and its components.
0118    */
0119   //@{
0120   /**
0121    * Subscript operator for the wavefunction.
0122    */
0123   Complex operator ()(int i, int j, int k) const {
0124     return _wf(i,j,k);
0125   }
0126
0127   /**
0128    * Set components by index.
0129    */
0130   Complex & operator () (int i, int j, int k) {
0131     return _wf(i,j,k);
0132   }
0133
0134   /**
0135    * Return wavefunction as polarization rank-3 tensor .
0136    */
0137   const LorentzRank3Tensor<double> & wave() const {return _wf;}
0138   //@}
0139
0140   /**
0141    * Reset functions.
0142    */
0143   //@{
0144
0145   /**
0146    * Reset helicity (recalculate the tensor ).
0147    * @param ihel The new helicity (0,1,2,3,4 as described above.)
0148    */
0149   void reset(unsigned int ihel) {
0150     calculateWaveFunction(ihel);
0151   }
0152   //@}
0153
0154 public:
0155
0156   /**
0157    *  Perform the Lorentz transformation of the wave function
0158    */
0159   void transform(const LorentzRotation & r) {
0160     _wf.transform(r);
0161     transformMomentum(r);
0162   }
0163
0164 public:
0165
0166   /**
0167    *  Calculate the wavefunctions
0168    */
0169   static void calculateWaveFunctions(vector<LorentzRank3Tensor<double> > & waves,
0170                      tPPtr particle,Direction,bool massless);
0171
0172   /**
0173    *  Calculate the wavefunctions
0174    */
0175   static void calculateWaveFunctions(vector<Rank3TensorWaveFunction> & waves,
0176                      tPPtr particle,Direction,bool massless);
0177
0178   /**
0179    *  Calculate the wavefunctions
0180    */
0181   static void calculateWaveFunctions(vector<LorentzRank3Tensor<double> > & waves,
0182                      RhoDMatrix & rho,
0183                      tPPtr particle,Direction,bool massless);
0184
0185   /**
0186    *  Calculate the wavefunctions
0187    */
0188   static void calculateWaveFunctions(vector<Rank3TensorWaveFunction> & waves,
0189                      RhoDMatrix & rho,
0190                      tPPtr particle,Direction,bool massless);
0191
0192   /**
0193    *  Construct the SpinInfo object
0194    */
0195   static void constructSpinInfo(const vector<LorentzRank3Tensor<double> > & waves,
0196                 tPPtr part,Direction dir, bool time,bool massless);
0197
0198   /**
0199    *  Construct the SpinInfo object
0200    */
0201   static void constructSpinInfo(const vector<Rank3TensorWaveFunction> & waves,
0202                 tPPtr part,Direction dir, bool time,bool massless);
0203
0204 private:
0205
0206   /**
0207    * Calculate the wavefunction.
0208    * @param ihel The helicity (0,1,2,3,4 as described above.)
0209    */
0210   void calculateWaveFunction(unsigned int ihel);
0211
0212 private:
0213
0214   /**
0215    * Storage of the wavefunction as a Lorentz Rank3Tensor.
0216    */
0217   LorentzRank3Tensor<double> _wf;
0218
0219 };
0220 }
0221 }
0222
0223 #endif