ThePEG  1.8.0
VectorWaveFunction.h
1 // -*- C++ -*-
2 //
3 // VectorWaveFunction.h is a part of ThePEG - Toolkit for HEP Event Generation
4 // Copyright (C) 2003-2011 Peter Richardson, Leif Lonnblad
5 //
6 // ThePEG is licenced under version 2 of the GPL, see COPYING for details.
7 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
8 //
9 #ifndef ThePEG_VectorWaveFunction_H
10 #define ThePEG_VectorWaveFunction_H
11 //
12 // This is the declaration of the VectorWaveFunction class.
13 //
14 #include "WaveFunctionBase.h"
15 #include <ThePEG/Helicity/LorentzPolarizationVector.h>
16 #include <ThePEG/Helicity/VectorSpinInfo.h>
17 #include <ThePEG/EventRecord/RhoDMatrix.h>
18 #include <ThePEG/EventRecord/Particle.h>
19 
20 namespace ThePEG {
21 namespace Helicity {
22 
31 };
32 
61 
62 public:
63 
77  : WaveFunctionBase(p,part,dir), _wf(wave)
78  {
79  assert(iSpin()==3);
80  }
81 
92  const Complex & y,const Complex & z, const Complex & t)
93  : WaveFunctionBase(p,part), _wf(x,y,z,t)
94  {
95  assert(iSpin()==3);
96  }
97 
108  unsigned int ihel,Direction dir,
110  : WaveFunctionBase(p,part,dir)
111  {
112  assert(iSpin()==3);
113  calculateWaveFunction(ihel,phase);
114  }
115 
123  tcPDPtr part,Direction dir)
124  : WaveFunctionBase(p,part,dir), _wf()
125  {
126  assert(iSpin()==3);
127  }
128 
133 
137  VectorWaveFunction(vector<VectorWaveFunction> & wave,
138  tPPtr part,Direction dir,bool time,bool massless,
139  bool=true,
141  calculateWaveFunctions(wave,part,dir,massless,phase);
142  constructSpinInfo(wave,part,dir,time,massless);
143  }
145 
153  const LorentzPolarizationVector & wave() const { return _wf;}
154 
158  Complex x() const {return _wf.x();}
159 
163  Complex y() const {return _wf.y();}
164 
168  Complex z() const {return _wf.z();}
169 
173  Complex t() const {return _wf.t();}
174 
184  void reset(unsigned int ihel,VectorPhase phase=default_vector_phase) {
185  calculateWaveFunction(ihel,phase);
186  }
188 
189 public:
190 
194  void transform(const LorentzRotation & r) {
195  _wf.transform(r);
197  }
198 
199 public:
200 
204  static void calculateWaveFunctions(vector<LorentzPolarizationVector> & waves,
205  tPPtr particle,Direction,bool massless,
207 
211  static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
212  tPPtr particle,Direction,bool massless,
214 
218  static void calculateWaveFunctions(vector<LorentzPolarizationVector> & waves,
219  RhoDMatrix & rho,
220  tPPtr particle,Direction,bool massless,
222 
226  static void calculateWaveFunctions(vector<VectorWaveFunction> & waves,
227  RhoDMatrix & rho,
228  tPPtr particle,Direction,bool massless,
230 
234  static void constructSpinInfo(const vector<LorentzPolarizationVector> & waves,
235  tPPtr part,Direction dir, bool time,bool massless);
236 
240  static void constructSpinInfo(const vector<VectorWaveFunction> & waves,
241  tPPtr part,Direction dir, bool time,bool massless);
242 
243 private:
244 
250  void calculateWaveFunction(unsigned int ihel,
252 
253 private:
254 
259 
260 };
261 
262 }
263 }
264 
265 #endif
Complex t() const
Get t component.
Complex z() const
Get z component.
void reset(unsigned int ihel, VectorPhase phase=default_vector_phase)
Reset functions.
const LorentzPolarizationVector & wave() const
Access to the wavefunction and its components.
std::complex< double > Complex
ThePEG code should use Complex for all complex scalars.
Definition: Complex.h:23
void transform(const LorentzRotation &r)
Perform the Lorentz transformation of the wave function.
static void constructSpinInfo(const vector< LorentzPolarizationVector > &waves, tPPtr part, Direction dir, bool time, bool massless)
Construct the SpinInfo object.
static void calculateWaveFunctions(vector< LorentzPolarizationVector > &waves, tPPtr particle, Direction, bool massless, VectorPhase phase=default_vector_phase)
Calculate the wavefunctions.
TransientConstRCPtr is a simple wrapper around a bare const pointer which can be assigned to and from...
Definition: RCPtr.h:681
The LorentzRotation class combine a SpinOneLorentzRotation and a spin SpinHalfLorentzRotation to prov...
TransientRCPtr is a simple wrapper around a bare pointer which can be assigned to and from an RCPtr a...
Definition: RCPtr.h:509
VectorWaveFunction(const Lorentz5Momentum &p, tcPDPtr part, const Complex &x, const Complex &y, const Complex &z, const Complex &t)
Constructor, set the momentum and components of the wavefunction.
This is the main namespace within which all identifiers in ThePEG are declared.
Definition: FactoryBase.h:28
An intermediate particle.
Include the phase factor.
VectorWaveFunction(const Lorentz5Momentum &p, tcPDPtr part, unsigned int ihel, Direction dir, VectorPhase phase=default_vector_phase)
Constructor, set the momentum, helicity and direction, optionally the choice of the phase...
void calculateWaveFunction(unsigned int ihel, VectorPhase phase=default_vector_phase)
Calculate the wavefunction.
VectorPhase
Definition of the enumerated values of the phase to include in the calculation of the polarization ve...
PDT::Spin iSpin() const
Get 2s+1 for the particle.
Complex x() const
Get x component.
VectorWaveFunction(const Lorentz5Momentum &p, tcPDPtr part, Direction dir)
Constructor, set the 5-momentum and direction, zero the wavefunction.
LorentzPolarizationVector _wf
Storage of the wavefunction as a Lorentz Vector.
VectorWaveFunction(vector< VectorWaveFunction > &wave, tPPtr part, Direction dir, bool time, bool massless, bool=true, VectorPhase phase=default_vector_phase)
Special for spin correlations.
A Direction object can be used to specify that some following operations should be assumed to be perf...
Definition: Direction.h:41
Complex y() const
Get y component.
tcPDPtr particle() const
Get the particle pointer.
The RhoDMatrix class is designed to implement the storage of the rho and D matrices which are require...
Definition: RhoDMatrix.h:27
VectorWaveFunction(const Lorentz5Momentum &p, tcPDPtr part, const LorentzPolarizationVector &wave, Direction dir=intermediate)
Constructor, set the momentum and Wavefunction, the direction can also be specified.
LorentzVector< Value > & transform(const SpinOneLorentzRotation &m)
Rotate the vector. Resets .
void transformMomentum(const LorentzRotation &r)
Perform the Lorentz transformation of the wave function.