diff --git a/Helicity/Vertex/Scalar/GeneralVVSVertex.cc b/Helicity/Vertex/Scalar/GeneralVVSVertex.cc --- a/Helicity/Vertex/Scalar/GeneralVVSVertex.cc +++ b/Helicity/Vertex/Scalar/GeneralVVSVertex.cc @@ -1,125 +1,125 @@ // -*- C++ -*- // // This is the implementation of the non-inlined, non-templated member // functions of the GeneralVVSVertex class. // #include "GeneralVVSVertex.h" #include "ThePEG/Utilities/DescribeClass.h" #include "ThePEG/Interface/ClassDocumentation.h" #include "ThePEG/Helicity/epsilon.h" using namespace ThePEG; using namespace Helicity; // The following static variable is needed for the type // description system in ThePEG. DescribeAbstractNoPIOClass describeThePEGGeneralVVSVertex("ThePEG::GeneralVVSVertex", "libThePEG.so"); void GeneralVVSVertex::Init() { static ClassDocumentation documentation ("The GeneralVVSVertex class implements a general form of" " the vector-vector-scalar interaction"); } Complex GeneralVVSVertex::evaluate(Energy2 q2,const VectorWaveFunction & vec1, const VectorWaveFunction & vec2, const ScalarWaveFunction & sca) { Lorentz5Momentum pSca = sca.momentum(); Lorentz5Momentum pvec1 = vec1.momentum(); Lorentz5Momentum pvec2 = vec2.momentum(); // calculate kinematics if(kinematics()) calculateKinematics(pSca,pvec1,pvec2); // calculate coupling setCoupling(q2, vec1.particle(), vec2.particle(), sca.particle()); Complex e1e2(vec1.wave().dot(vec2.wave())); complex e1p1(vec1.wave().dot(pvec1)); complex e1p2(vec1.wave().dot(pvec2)); complex e2p1(vec2.wave().dot(pvec1)); complex e2p2(vec2.wave().dot(pvec2)); complex p1p2(invariant(1,2)); LorentzPolarizationVectorE eps = epsilon(vec1.wave(),vec2.wave(),pvec2); complex p1Ep2 = eps.dot(pvec1); Complex output = UnitRemoval::InvE2 * (_a00*e1e2*p1p2 + _aEp*p1Ep2 + _a11*e1p1*e2p1 + _a12*e1p1*e2p2 + _a21*e1p2*e2p1+ _a22*e1p2*e2p2); return -norm()*Complex(0.,1.) * sca.wave() * output; } ScalarWaveFunction GeneralVVSVertex::evaluate(Energy2 q2,int iopt, tcPDPtr out, const VectorWaveFunction & vec1, const VectorWaveFunction & vec2, complex mass, complex width) { // pointers to the particle data objects tcPDPtr Pvec1(vec1.particle()); tcPDPtr Pvec2(vec2.particle()); Lorentz5Momentum pvec1 = vec1.momentum(); Lorentz5Momentum pvec2 = vec2.momentum(); Lorentz5Momentum pout = pvec1 + pvec2; pout.rescaleMass(); // calculate kinematics if needed - if(kinematics()) calculateKinematics(pout,pvec1,pvec2); + if(kinematics()) calculateKinematics(-pout,pvec1,pvec2); // calculate coupling setCoupling(q2,Pvec1,Pvec2,out); // propagator Complex prop = propagator(iopt,pout.m2(),out,mass,width); // lorentz part Complex e1e2(vec1.wave().dot(vec2.wave())); complex e1p1(vec1.wave().dot(pvec1)); complex e1p2(vec1.wave().dot(pvec2)); complex e2p1(vec2.wave().dot(pvec1)); complex e2p2(vec2.wave().dot(pvec2)); complex p1p2(invariant(1,2)); LorentzPolarizationVectorE eps = epsilon(vec1.wave(),vec2.wave(),pvec2); complex p1Ep2 = eps.dot(pvec1); Complex output = UnitRemoval::InvE2 * (_a00*e1e2*p1p2 + _aEp*p1Ep2 + _a11*e1p1*e2p1 + _a12*e1p1*e2p2 + _a21*e1p2*e2p1+ _a22*e1p2*e2p2); output *= norm()*prop; return ScalarWaveFunction(pout,out,output); } VectorWaveFunction GeneralVVSVertex::evaluate(Energy2 q2,int iopt,tcPDPtr out, const VectorWaveFunction & vec, const ScalarWaveFunction & sca, complex mass, complex width) { Lorentz5Momentum pSca = sca.momentum(); Lorentz5Momentum pvec1 = vec.momentum()+sca.momentum(); Lorentz5Momentum pvec2 = vec.momentum(); // calculate kinematics - if(kinematics()) calculateKinematics(pSca,pvec1,pvec2); + if(kinematics()) calculateKinematics(pSca,-pvec1,pvec2); // calculate coupling setCoupling(q2, out, vec.particle(), sca.particle()); // prefactor Energy2 p2 = pvec1.m2(); if(mass.real() < ZERO) mass = out->mass(); complex mass2 = sqr(mass); Complex fact = -norm()* sca.wave() * propagator(iopt,p2,out,mass,width); // vertex as polarization vector - complex e2p1(vec.wave().dot(pvec1)); + complex e2p1(-vec.wave().dot(pvec1)); complex e2p2(vec.wave().dot(pvec2)); complex p1p2(invariant(1,2)); - LorentzPolarizationVector pv = (UnitRemoval::InvE2*_a00*p1p2*vec.wave() + - UnitRemoval::InvE2*_a11*e2p1*pvec1 + + LorentzPolarizationVector pv = (UnitRemoval::InvE2*_a00*p1p2*vec.wave() - + UnitRemoval::InvE2*_a11*e2p1*pvec1 - UnitRemoval::InvE2*_a12*e2p2*pvec1 + UnitRemoval::InvE2*_a21*e2p1*pvec2 + - UnitRemoval::InvE2*_a22*e2p2*pvec2 - + UnitRemoval::InvE2*_a22*e2p2*pvec2 + UnitRemoval::InvE2*_aEp*epsilon(pvec1,vec.wave(),pvec2)); // evaluate the wavefunction LorentzPolarizationVector vect; // massless case if(mass.real()==ZERO) { vect = fact*pv; } // massive case else { complex dot = pv.dot(pvec1)/mass2; vect = fact*(pv-dot*pvec1); } return VectorWaveFunction(pvec1,out,vect); } diff --git a/Helicity/Vertex/Scalar/SSSVertex.cc b/Helicity/Vertex/Scalar/SSSVertex.cc --- a/Helicity/Vertex/Scalar/SSSVertex.cc +++ b/Helicity/Vertex/Scalar/SSSVertex.cc @@ -1,60 +1,60 @@ // -*- C++ -*- // // SSSVertex.cc is a part of ThePEG - Toolkit for HEP Event Generation // Copyright (C) 2003-2017 Peter Richardson, Leif Lonnblad // // ThePEG is licenced under version 3 of the GPL, see COPYING for details. // Please respect the MCnet academic guidelines, see GUIDELINES for details. // // // This is the implementation of the non-inlined, non-templated member // functions of the SSSVertex class. // #include "SSSVertex.h" #include "ThePEG/Utilities/DescribeClass.h" #include "ThePEG/Interface/ClassDocumentation.h" using namespace ThePEG; using namespace Helicity; // The following static variable is needed for the type // description system in ThePEG. DescribeAbstractNoPIOClass describeThePEGSSSVertex("ThePEG::SSSVertex", "libThePEG.so"); void SSSVertex::Init() { static ClassDocumentation documentation ("The SSSVertex class is the implementation of the SSS" "vertex. All such vertices shoud inherit from it"); } // evaluate the vertex Complex SSSVertex::evaluate(Energy2 q2, const ScalarWaveFunction & sca1, const ScalarWaveFunction & sca2, const ScalarWaveFunction & sca3) { if(kinematics()) calculateKinematics(sca1.momentum(),sca2.momentum(),sca3.momentum()); // calculate the coupling setCoupling(q2,sca1.particle(),sca2.particle(),sca3.particle()); // return the answer return Complex(0.,1.)*norm()*sca1.wave()*sca2.wave()*sca3.wave(); } // off-shell scalar ScalarWaveFunction SSSVertex::evaluate(Energy2 q2,int iopt, tcPDPtr out, const ScalarWaveFunction & sca1, const ScalarWaveFunction & sca2, complex mass, complex width) { // outgoing momentum Lorentz5Momentum pout = sca1.momentum()+sca2.momentum(); - if(kinematics()) calculateKinematics(sca1.momentum(),sca2.momentum(),pout); + if(kinematics()) calculateKinematics(sca1.momentum(),sca2.momentum(),-pout); // calculate the coupling setCoupling(q2,sca1.particle(),sca2.particle(),out); // wavefunction Energy2 p2=pout.m2(); Complex fact=-norm()*sca1.wave()*sca2.wave()*propagator(iopt,p2,out,mass,width); return ScalarWaveFunction(pout,out,fact); }