diff --git a/include/RHEJ/Tensor.hh b/include/RHEJ/Tensor.hh new file mode 100644 index 0000000..4cba58b --- /dev/null +++ b/include/RHEJ/Tensor.hh @@ -0,0 +1,199 @@ +/** \file + * \brief Tensor Template Class declaration. + * + * This file contains the declaration of the Tensor Template class. This + * is used to calculate some of the more complex currents within the + * W+Jets implementation particularly. + */ + +#include + +template + class Tensor + { + public: + + //Constructor + Tensor(void); + Tensor(COM x); + + //Destructor + virtual ~Tensor(void); + + int rank(void){ + return N; + } + + int dim(void){ + return D; + } + + int len(){ + return size; + } + + COM at(int i){ + return components[i]; + } + COM at(int i, int j) { + return components[D*i +j]; + } + COM at(int i, int j, int k) { + return components[D*(D*i + j)+ k]; + } + COM at(int i,int j, int k,int l) { + return components[D*(D*(D*i +j) + k) + l]; + } + COM at(int i,int j, int k,int l, int m){ + return components[D*(D*(D*(D*i + j) + k) + l) + m]; + } + + bool isSet(void){ + if(components.size()==0) + return false; + else + return true; + } + + void Fill(COM x){ + components=x; + } + + //Set component indexed by i,j,k,l,m + void Set(int i,COM x){ + components[i] = x; + } + void Set(int i, int j, COM x) { + components[D*i +j] = x; + } + void Set(int i, int j, int k, COM x) { + components[D*(D*i + j)+ k] = x; + } + void Set(int i,int j, int k,int l,COM x) { + components[D*(D*(D*i +j) + k) + l] = x; + } + void Set(int i,int j, int k,int l, int m, COM x){ + components[D*(D*(D*(D*i + j) + k) + l) + m] = x; + } + + Tensor operator*(const double x){ + Tensor newT; + newT.components=components*COM(x,0); + return newT; + } + Tensor operator*(const COM x){ + Tensor newT; + newT.components=components*x; + return newT; + } + Tensor operator/(const double x){ + Tensor newT; + newT.components=components/COM(x,0); + return newT; + } + Tensor operator/(const COM x){ + Tensor newT; + newT.components=components/x; + return newT; + } + Tensor operator+(const Tensor T2){ + Tensor newT; + newT.components=components+T2.components; + return newT; + } + Tensor operator-(const Tensor T2){ + Tensor newT; + newT.components=components-T2.components; + return newT; + } + void operator+=(const Tensor T2){ + components = components+T2.components; + } + void operator-=(const Tensor T2){ + components=components-T2.components; + } + + Tensor rightprod(const Tensor<1,D> T2){ + Tensor newT; + for(int i=0; i leftprod(const Tensor<1,D> T2){ + Tensor newT; + for(unsigned int j=0;j contract(const Tensor<1,D> T2, int k){ + Tensor newT; + for(int j=0; j components; + + private: + + int size; + COM sign(unsigned int i){ + if(i==0) + return 1.; + else + return -1.; + } + + }; + +template Tensor::Tensor(void) +{ + size = pow(D,N); + components.resize(size); +} +template Tensor::Tensor(COM x) { + size = pow(D,N); + components.resize(size, x); +} +template Tensor::~Tensor(void) {} + + +// Tensor Functions: +// Tensor<1,4> Sigma(int i, int j, bool hel); +// Tensor<2,4> Metric(void); +// int tensor2listindex(std::array indexlist); +// int tensor2listindex(std::array indexlist); +// void perms41(int same4, int diff, std::vector> * perms); +// void perms32(int same3, int diff, std::vector> * perms); +// void perms311(int same3, int diff1, int diff2, std::vector> * perms); +// void perms221(int same2a, int same2b, int diff, std::vector> * perms); +// void perms2111(int same2, int diff1,int diff2,int diff3, std::vector> * perms); +// void perms21(int same, int diff, std::vector> * perms); +// void perms111(int diff1, int diff2, int diff3, std::vector> * perms); + + +Tensor<2,4> Metric(void); +Tensor<1,4> TCurrent(CLHEP::HepLorentzVector p1, bool h1,CLHEP::HepLorentzVector p2, bool h2); +Tensor<3,4> T3Current(CLHEP::HepLorentzVector p1, bool h1,CLHEP::HepLorentzVector p2, bool h2); +Tensor<5,4> T5Current(CLHEP::HepLorentzVector p1, bool h1,CLHEP::HepLorentzVector p2, bool h2); +Tensor<1,4> Construct1Tensor(CCurrent j); +Tensor<1,4> Construct1Tensor(CLHEP::HepLorentzVector p); +Tensor<1,4> eps(CLHEP::HepLorentzVector k, CLHEP::HepLorentzVector ref, bool pol); +bool init_sigma_index(void); diff --git a/include/RHEJ/currents.hh b/include/RHEJ/currents.hh index 89ed652..ca8af5e 100644 --- a/include/RHEJ/currents.hh +++ b/include/RHEJ/currents.hh @@ -1,875 +1,1322 @@ ////////////////////////////////////////////////// ////////////////////////////////////////////////// // This source code is Copyright (2012) of // // Jeppe R. Andersen and Jennifer M. Smillie // // and is distributed under the // // Gnu Public License version 2 // // http://www.gnu.org/licenses/gpl-2.0.html // // You are allowed to distribute and alter the // // source under the conditions of the GPLv2 // // as long as this copyright notice // // is unaltered and distributed with the source // // Any use should comply with the // // MCNET GUIDELINES // // for Event Generator Authors and Users // // as distributed with this source code // ////////////////////////////////////////////////// ////////////////////////////////////////////////// /** \file * \brief Functions computing the square of current contractions. * * This file contains all the necessary functions to compute the current * contractions for all valid HEJ processes. PJETS, H+JETS and W+JETS along with * some unordered counterparts. */ #pragma once #include #include #include +#include #include typedef std::complex COM; typedef COM current[4]; typedef CLHEP::HepLorentzVector HLV; //! The Higgs field vacuum expectation value in GeV static constexpr double v = 246.; constexpr double infinity = std::numeric_limits::infinity(); constexpr double mb_default = 4.7; void Setup_Currents(void); + //! Square of qQ->qenuQ W+Jets Scattering Current /** * @param p1out Momentum of final state quark * @param pe Momentum of final state electron * @param pnu Momentum of final state Neutrino * @param p1in Momentum of initial state quark * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @returns Square of the current contractions for qQ->qenuQ Scattering * * This returns the square of the current contractions in qQ->qenuQ scattering * with an emission of a W Boson. */ double jMWqQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qbarQ->qbarenuQ W+Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param pe Momentum of final state electron * @param pnu Momentum of final state Neutrino * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @returns Square of the current contractions for qbarQ->qbarenuQ Scattering * * This returns the square of the current contractions in qbarQ->qbarenuQ scattering * with an emission of a W Boson. */ double jMWqbarQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qQbar->qenuQbar W+Jets Scattering Current /** * @param p1out Momentum of final state quark * @param pe Momentum of final state electron * @param pnu Momentum of final state Neutrino * @param p1in Momentum of initial state quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @returns Square of the current contractions for qQbar->qenuQbar Scattering * * This returns the square of the current contractions in qQbar->qenuQbar scattering * with an emission of a W Boson. */ double jMWqQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qbarQbar->qbarenuQbar W+Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param pe Momentum of final state electron * @param pnu Momentum of final state Neutrino * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @returns Square of the current contractions for qbarQbar->qbarenuQbar Scattering * * This returns the square of the current contractions in qbarQbar->qbarenuQbar scattering * with an emission of a W Boson. */ double jMWqbarQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qg->qenug W+Jets Scattering Current /** * @param p1out Momentum of final state quark * @param pe Momentum of final state electron * @param pnu Momentum of final state Neutrino * @param p1in Momentum of initial state quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @returns Square of the current contractions for qg->qenug Scattering * * This returns the square of the current contractions in qg->qenug scattering * with an emission of a W Boson. */ double jMWqg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qbarg->qbarenug W+Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param pe Momentum of final state electron * @param pnu Momentum of final state Neutrino * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @returns Square of the current contractions for qbarg->qbarenug Scattering * * This returns the square of the current contractions in qbarg->qbarenug scattering * with an emission of a W Boson. */ double jMWqbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); +// W+Jets Unordered Functions + +//! qQg Wjets Unordered backwards opposite leg to W +/** + * @param p1out Momentum of final state quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state quark b + * @param p2in Momentum of intial state quark b + * @param pg Momentum of final state unordered gluon + * @returns Square of the current contractions for qQ->qQg Scattering + * + * This returns the square of the current contractions in qQg->qQg scattering + * with an emission of a W Boson. + */ +double junobMWqQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg); + +//! qbarQg Wjets Unordered backwards opposite leg to W +/** + * @param p1out Momentum of final state anti-quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state anti-quark a + * @param p2out Momentum of final state quark b + * @param p2in Momentum of intial state quark b + * @param pg Momentum of final state unordered gluon + * @returns Square of the current contractions for qbarQ->qbarQg Scattering + * + * This returns the square of the current contractions in qbarQg->qbarQg scattering + * with an emission of a W Boson. + */ +double junobMWqbarQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg); + + + +//! qQbarg Wjets Unordered backwards opposite leg to W +/** + * @param p1out Momentum of final state quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state anti-quark b + * @param p2in Momentum of intial state anti-quark b + * @param pg Momentum of final state unordered gluon + * @returns Square of the current contractions for qQbar->qQbarg Scattering + * + * This returns the square of the current contractions in qQbarg->qQbarg scattering + * with an emission of a W Boson. + */ +double junobMWqQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg); + +//! qbarQbarg Wjets Unordered backwards opposite leg to W +/** + * @param p1out Momentum of final state anti-quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state anti-quark a + * @param p2out Momentum of final state anti-quark b + * @param p2in Momentum of intial state anti-quark b + * @param pg Momentum of final state unordered gluon + * @returns Square of the current contractions for qbarQbar->qbarQbarg Scattering + * + * This returns the square of the current contractions in qbarQbarg->qbarQbarg scattering + * with an emission of a W Boson. + */ +double junobMWqbarQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg); + + +//!Wjets Unordered forwards opposite leg to W +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state quark b + * @param p2in Momentum of intial state quark b + * @returns Square of the current contractions for qQ->gqQ Scattering + * + * This returns the square of the current contractions in qQg->gqQ scattering + * with an emission of a W Boson. + */ +double junofMWgqQ (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in); + +//!Wjets Unordered forwards opposite leg to W +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state anti-quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state anti-quark a + * @param p2out Momentum of final state quark b + * @param p2in Momentum of intial state quark b + * @returns Square of the current contractions for qbarQ->gqbarQ Scattering + * + * This returns the square of the current contractions in qbarQg->gqbarQ scattering + * with an emission of a W Boson. + */ +double junofMWgqbarQ (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in); + +//!Wjets Unordered forwards opposite leg to W +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state anti-quark b + * @param p2in Momentum of intial state anti-quark b + * @returns Square of the current contractions for qQbar->gqQbar Scattering + * + * This returns the square of the current contractions in qQbarg->gqQbar scattering + * with an emission of a W Boson. + */ +double junofMWgqQbar (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in); + +//!Wjets Unordered forwards opposite leg to W +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state anti-quark a + * @param pe Momentum of final state electron + * @param pnu Momentum of final state Neutrino + * @param p1in Momentum of initial state anti-quark a + * @param p2out Momentum of final state anti-quark b + * @param p2in Momentum of intial state anti-quark b + * @returns Square of the current contractions for qbarQbar->gqbarQbar Scattering + * + * This returns the square of the current contractions in qbarQbarg->gqbarQbar scattering + * with an emission of a W Boson. + */ +double junofMWgqbarQbar (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in); + +//!W+uno same leg +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state quark b + * @param p2in Momentum of intial state quark b + * @returns Square of the current contractions for qQ->qQg Scattering + * + * This returns the square of the current contractions in gqQ->gqQ scattering + * with an emission of a W Boson. + */ +double jM2WunogqQ(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//! TODO: What does this function do? Crossed contribution is Exqqx..? +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state quark b + * @param p2in Momentum of intial state quark b + * @returns Square of the current contractions for qQ->gqQ Scattering + * + * This returns the square of the current contractions in gqQ->gqQ scattering + * with an emission of a W Boson. + */ +double jM2WunogqQ_crossqQ(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//! W+uno same leg. quark anti-quark +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state anti-quark b + * @param p2in Momentum of intial state anti-quark b + * @returns Square of the current contractions for qQbar->gqQbar Scattering + * + * This returns the square of the current contractions in gqQbar->gqQbar scattering + * with an emission of a W Boson. (Unordered Same Leg) + */ +double jM2WunogqQbar(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//! W+uno same leg. quark gluon +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param p1in Momentum of initial state quark a + * @param p2out Momentum of final state gluon b + * @param p2in Momentum of intial state gluon b + * @returns Square of the current contractions for qg->gqg Scattering + * + * This returns the square of the current contractions in qg->gqg scattering + * with an emission of a W Boson. + */ +double jM2Wunogqg(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//! W+uno same leg. anti-quark quark +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state anti-quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param p1in Momentum of initial state anti-quark a + * @param p2out Momentum of final state quark b + * @param p2in Momentum of intial state quark b + * @returns Square of the current contractions for qbarQ->gqbarQ Scattering + * + * This returns the square of the current contractions in qbarQ->gqbarQ scattering + * with an emission of a W Boson. + */ +double jM2WunogqbarQ(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//! W+uno same leg. anti-quark anti-quark +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state anti-quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param p1in Momentum of initial state anti-quark a + * @param p2out Momentum of final state anti-quark b + * @param p2in Momentum of intial state anti-quark b + * @returns Square of the current contractions for qbarQbar->gqbarQbar Scattering + * + * This returns the square of the current contractions in gqbarQbar->qbarQbar scattering + * with an emission of a W Boson. + */ +double jM2WunogqbarQbar(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//! W+uno same leg. anti-quark gluon +/** + * @param pg Momentum of final state unordered gluon + * @param p1out Momentum of final state anti-quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param p1in Momentum of initial state anti-quark a + * @param p2out Momentum of final state gluon b + * @param p2in Momentum of intial state gluon b + * @returns Square of the current contractions for ->gqbarg Scattering + * + * This returns the square of the current contractions in qbarg->gqbarg scattering + * with an emission of a W Boson. + */ +double jM2Wunogqbarg(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//W+Jets qqxExtremal +//! W+Extremal qqx. qxqQ +/** + * @param pgin Momentum of initial state gluon + * @param pqout Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param pqbarout Momentum of final state anti-quark a + * @param p2out Momentum of initial state anti-quark b + * @param p2in Momentum of final state gluon b + * @returns Square of the current contractions for ->qbarqQ Scattering + * + * Calculates the square of the current contractions with extremal qqbar pair + * production. This is calculated through the use of crossing symmetry. + */ +double jM2WgQtoqbarqQ(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqbarout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//W+Jets qqxExtremal +//! W+Extremal qqx. qqxQ +/** + * @param pgin Momentum of initial state gluon + * @param pqout Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param pqbarout Momentum of final state anti-quark a + * @param p2out Momentum of initial state anti-quark b + * @param p2in Momentum of final state gluon b + * @returns Square of the current contractions for ->qqbarQ Scattering + * + * Calculates the square of the current contractions with extremal qqbar pair + * production. This is calculated through the use of crossing symmetry. + */ +double jM2WgQtoqqbarQ(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqbarout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//W+Jets qqxExtremal +//! W+Extremal qqx. gg->qxqg +/** + * @param pgin Momentum of initial state gluon + * @param pqout Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param pqbarout Momentum of final state anti-quark a + * @param p2out Momentum of initial state gluon b + * @param p2in Momentum of final state gluon b + * @returns Square of the current contractions for gg->qbarqg Scattering + * + * Calculates the square of the current contractions with extremal qqbar pair + * production. This is calculated through the use of crossing symmetry. + */ +double jM2Wggtoqbarqg(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqbarout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//W+Jets qqxExtremal +//! W+Extremal qqx. gg->qqxg +/** + * @param pgin Momentum of initial state gluon + * @param pqout Momentum of final state quark a + * @param plbar Momentum of final state anti-lepton + * @param pl Momentum of final state lepton + * @param pqbarout Momentum of final state anti-quark a + * @param p2out Momentum of initial state gluon a + * @param p2in Momentum of final state gluon b + * @returns Square of the current contractions for gg->qqbarg Scattering + * + * Calculates the square of the current contractions with extremal qqbar pair + * production. This is calculated through the use of crossing symmetry. + */ +double jM2Wggtoqqbarg(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqbarout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); + +//! W+Jets qqxCentral. qqx W emission. +/** + * @param pa Momentum of initial state particle a + * @param pb Momentum of initial state particle b + * @param pl Momentum of final state lepton + * @param plbar Momentum of final state anti-lepton + * @param partons Vector of outgoing parton momenta + * @param aqlinepa Bool: True= pa is anti-quark + * @param aqlinepb Bool: True= pb is anti-quark + * @param qqxmarker Bool: Ordering of the qqbar pair produced (qqx vs qxq) + * @param nabove Number of lipatov vertices "above" qqbar pair + * @param nbelow Number of lipatov vertices "below" qqbar pair + * @returns Square of the current contractions for qq>qQQbarWq Scattering + * + * Calculates the square of the current contractions with extremal qqbar pair + * production. This is calculated through the use of crossing symmetry. + */ +double jM2WqqtoqQQq(HLV pa, HLV pb,HLV pl,HLV plbar, std::vector partons, bool aqlinepa, bool aqlinepb, bool qqxmarker, int nabove, int nbelow); //Doing +//emission from backwards leg + +//! W+Jets qqxCentral. W emission from backwards leg. +/** + * @param ka HLV: Momentum of initial state particle a + * @param kb HLV: Momentum of initial state particle b + * @param pl HLV: Momentum of final state lepton + * @param plbar HLV: Momentum of final state anti-lepton + * @param partons Vector(HLV): outgoing parton momenta + * @param aqlinepa Bool: True= pa is anti-quark + * @param aqlinepb Bool: True= pb is anti-quark + * @param qqxmarker Bool: Ordering of the qqbar pair produced (qqx vs qxq) + * @param nabove Int: Number of lipatov vertices "above" qqbar pair + * @param nbelow Int: Number of lipatov vertices "below" qqbar pair + * @param forwards Bool: Swap to emission off front leg TODO:remove so args can be const + * @returns Square of the current contractions for qq>qQQbarWq Scattering + * + * Calculates the square of the current contractions with extremal qqbar pair + * production. This is calculated through the use of crossing symmetry. + */ +double jM2WqqtoqQQqW(HLV ka, HLV kb,HLV pl,HLV plbar, std::vector partons, bool aqlinepa, bool aqlinepb, bool qqxmarker, int nabove, int nbelow, bool forwards); //Doing + + + //! Square of qQ->qQ Pure Jets Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @returns Square of the current contractions for qQ->qQ Scattering * * This returns the square of the current contractions in qQ->qQ Pure Jet Scattering. */ double jM2qQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qQbar->qQbar Pure Jets Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @returns Square of the current contractions for qQbar->qQbar Scattering * * This returns the square of the current contractions in qQbar->qQbar Pure Jet Scattering. * Note this can be used for qbarQ->qbarQ Scattering by inputting arguments appropriately. */ double jM2qQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qbarQbar->qbarQbar Pure Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @returns Square of the current contractions for qbarQbar->qbarQbar Scattering * * This returns the square of the current contractions in qbarQbar->qbarQbar Pure Jet Scattering. */ double jM2qbarQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qg->qg Pure Jets Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @returns Square of the current contractions for qg->qg Scattering * * This returns the square of the current contractions in qg->qg Pure Jet Scattering. * Note this can be used for gq->gq Scattering by inputting arguments appropriately. */ double jM2qg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of qbarg->qbarg Pure Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @returns Square of the current contractions for qbarg->qbarg Scattering * * This returns the square of the current contractions in qbarg->qbarg Pure Jet Scattering. * Note this can be used for gqbar->gqbar Scattering by inputting arguments appropriately. */ double jM2qbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of gg->gg Pure Jets Scattering Current /** * @param p1out Momentum of final state gluon * @param p1in Momentum of initial state gluon * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @returns Square of the current contractions for gg->gg Scattering * * This returns the square of the current contractions in gg->gg Pure Jet Scattering. */ double jM2gg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in); //! Square of gg->gg Higgs+Jets Scattering Current /** * @param p1out Momentum of final state gluon * @param p1in Momentum of initial state gluon * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @param q1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for gg->gg Scattering * * This returns the square of the current contractions in gg->gg Higgs+Jet Scattering. * * g~p1 g~p2 * should be called with q1 meant to be contracted with p2 in first part of vertex * (i.e. if g is backward, q1 is forward) */ double MH2gg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of gq->gq Higgs+Jets Scattering Current with Higgs before Gluon /** * @param p1out Momentum of final state gluon * @param p1in Momentum of initial state gluon * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @param pH Momentum of Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contraction * */ double MH2gq_outsideH(CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pH, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qg->qg Higgs+Jets Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @param q1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qg->qg Scattering * * This returns the square of the current contractions in qg->qg Higgs+Jet Scattering. * * q~p1 g~p2 (i.e. ALWAYS p1 for quark, p2 for gluon) * should be called with q1 meant to be contracted with p2 in first part of vertex * (i.e. if g is backward, q1 is forward) */ double MH2qg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qbarg->qbarg Higgs+Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @param q1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarg->qbarg Scattering * * This returns the square of the current contractions in qbarg->qbarg Higgs+Jet Scattering. * * qbar~p1 g~p2 (i.e. ALWAYS p1 for anti-quark, p2 for gluon) * should be called with q1 meant to be contracted with p2 in first part of vertex * (i.e. if g is backward, q1 is forward) */ double MH2qbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qQ->qQ Higgs+Jets Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @param q1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qQ->qQ Scattering * * This returns the square of the current contractions in qQ->qQ Higgs+Jet Scattering. * * q~p1 Q~p2 (i.e. ALWAYS p1 for quark, p2 for quark) * should be called with q1 meant to be contracted with p2 in first part of vertex * (i.e. if Q is backward, q1 is forward) */ double MH2qQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qQbar->qQbar Higgs+Jets Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @param q1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qQ->qQ Scattering * * This returns the square of the current contractions in qQbar->qQbar Higgs+Jet Scattering. * * q~p1 Qbar~p2 (i.e. ALWAYS p1 for quark, p2 for anti-quark) * should be called with q1 meant to be contracted with p2 in first part of vertex * (i.e. if Qbar is backward, q1 is forward) */ double MH2qQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qbarQ->qbarQ Higgs+Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @param q1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarQ->qbarQ Scattering * * This returns the square of the current contractions in qbarQ->qbarQ Higgs+Jet Scattering. * * qbar~p1 Q~p2 (i.e. ALWAYS p1 for anti-quark, p2 for quark) * should be called with q1 meant to be contracted with p2 in first part of vertex * (i.e. if Q is backward, q1 is forward) */ double MH2qbarQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qbarQbar->qbarQbar Higgs+Jets Scattering Current /** * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @param q1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarQbar->qbarQbar Scattering * * This returns the square of the current contractions in qbarQbar->qbarQbar Higgs+Jet Scattering. * * qbar~p1 Qbar~p2 (i.e. ALWAYS p1 for anti-quark, p2 for anti-quark) * should be called with q1 meant to be contracted with p2 in first part of vertex * (i.e. if Qbar is backward, q1 is forward) */ double MH2qbarQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); // Unordered f //! Square of qQ->gqQ Higgs+Jets Unordered f Scattering Current /** * @param pg Momentum of unordered gluon * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qQ->gqQ Scattering * * This returns the square of the current contractions in qQ->gqQ Higgs+Jet Scattering. * * This construction is taking rapidity order: pg > p1out >> p2out */ double jM2unogqHQ (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qQbar->gqQbar Higgs+Jets Unordered f Scattering Current /** * @param pg Momentum of unordered gluon * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qQbar->gqQbar Scattering * * This returns the square of the current contractions in qQbar->gqQbar Higgs+Jet Scattering. * * This construction is taking rapidity order: pg > p1out >> p2out */ double jM2unogqHQbar (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qbarQ->gqbarQ Higgs+Jets Unordered f Scattering Current /** * @param pg Momentum of unordered gluon * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarQ->gqbarQ Scattering * * This returns the square of the current contractions in qbarQ->gqbarQ Higgs+Jet Scattering. * * This construction is taking rapidity order: pg > p1out >> p2out */ double jM2unogqbarHQ (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qbarQbar->gqbarQbar Higgs+Jets Unordered f Scattering Current /** * @param pg Momentum of unordered gluon * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarQbar->gqbarQbar Scattering * * This returns the square of the current contractions in qbarQbar->gqbarQbar Higgs+Jet Scattering. * * This construction is taking rapidity order: pg > p1out >> p2out */ double jM2unogqbarHQbar (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qg->gqg Higgs+Jets Unordered f Scattering Current /** * @param pg Momentum of unordered gluon * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qg->gqg Scattering * * This returns the square of the current contractions in qg->gqg Higgs+Jet Scattering. * * This construction is taking rapidity order: pg > p1out >> p2out */ double jM2unogqHg (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qbarg->gqbarg Higgs+Jets Unordered f Scattering Current /** * @param pg Momentum of unordered gluon * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param p2out Momentum of final state gluon * @param p2in Momentum of intial state gluon * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarg->gbarg Scattering * * This returns the square of the current contractions in qbarg->gqbarg Higgs+Jet Scattering. * * This construction is taking rapidity order: pg > p1out >> p2out */ double jM2unogqbarHg (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //Unordered b //! Square of qbarQ->qbarQg Higgs+Jets Unordered b Scattering Current /** * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param pg Momentum of unordered b gluon * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarQ->qbarQg Scattering * * This returns the square of the current contractions in qbarQ->qbarQg Higgs+Jet Scattering. * * This construction is taking rapidity order: p1out >> p2out > pg */ double jM2unobqbarHQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qQ->qQg Higgs+Jets Unordered b Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param pg Momentum of unordered b gluon * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qQ->qQg Scattering * * This returns the square of the current contractions in qQ->qQg Higgs+Jet Scattering. * * This construction is taking rapidity order: p1out >> p2out > pg */ double jM2unobqHQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qQbar->qQbarg Higgs+Jets Unordered b Scattering Current /** * @param p1out Momentum of final state quark * @param p1in Momentum of initial state quark * @param pg Momentum of unordered b gluon * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qQbar->qQbarg Scattering * * This returns the square of the current contractions in qQbar->qQbarg Higgs+Jet Scattering. * * This construction is taking rapidity order: p1out >> p2out > pg */ double jM2unobqHQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of qbarQbar->qbarQbarg Higgs+Jets Unordered b Scattering Current /** * @param p1out Momentum of final state anti-quark * @param p1in Momentum of initial state anti-quark * @param pg Momentum of unordered b gluon * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for qbarQbar->qbarQbarg Scattering * * This returns the square of the current contractions in qbarQbar->qbarQbarg Higgs+Jet Scattering. * * This construction is taking rapidity order: p1out >> p2out > pg */ double jM2unobqbarHQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of gQbar->gQbarg Higgs+Jets Unordered b Scattering Current /** * @param p1out Momentum of final state gluon * @param p1in Momentum of initial state gluon * @param pg Momentum of unordered b gluon * @param p2out Momentum of final state anti-quark * @param p2in Momentum of intial state anti-quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for gQbar->gQbarg Scattering * * This returns the square of the current contractions in gQbar->gQbarg Higgs+Jet Scattering. * * This construction is taking rapidity order: p1out >> p2out > pg */ double jM2unobgHQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); //! Square of gQ->gQg Higgs+Jets Unordered b Scattering Current /** * @param p1out Momentum of final state gluon * @param p1in Momentum of initial state gluon * @param pg Momentum of unordered b gluon * @param p2out Momentum of final state quark * @param p2in Momentum of intial state quark * @param qH1 Momentum of t-channel propagator before Higgs * @param qH2 Momentum of t-channel propagator after Higgs * @param mt Top quark mass * @param include_bottom Specifies whether bottom corrections are included * @param mb Bottom quark mass * @returns Square of the current contractions for gQ->gQg Scattering * * This returns the square of the current contractions in gQ->gQg Higgs+Jet Scattering. * * This construction is taking rapidity order: p1out >> p2out > pg */ double jM2unobgHQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt = infinity, bool include_bottom = false, double mb = mb_default); // impact factors for Higgs + jet //! Implements Eq. (4.22) in hep-ph/0301013 with modifications to incoming plus momenta /** * @param p2 Momentum of Particle 2 * @param p1 Momentum of Particle 1 * @param pH Momentum of Higgs * @returns Value of Eq. (4.22) in Hep-ph/0301013 with modifications * * This gives the impact factor. First it determines first whether this is the case * p1p\sim php>>p3p or the opposite */ double C2gHgm(CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH); //! Implements Eq. (4.23) in hep-ph/0301013 with modifications to incoming plus momenta /** * @param p2 Momentum of Particle 2 * @param p1 Momentum of Particle 1 * @param pH Momentum of Higgs * @returns Value of Eq. (4.23) in Hep-ph/0301013 * * This gives the impact factor. First it determines first whether this is the case * p1p\sim php>>p3p or the opposite */ double C2gHgp(CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH); //! Implements Eq. (4.22) in hep-ph/0301013 /** * @param p2 Momentum of Particle 2 * @param p1 Momentum of Particle 1 * @param pH Momentum of Higgs * @returns Value of Eq. (4.22) in Hep-ph/0301013 * * This gives the impact factor. First it determines first whether this is the case * p1p\sim php>>p3p or the opposite */ double C2qHqm(CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH); /** \class CCurrent currents.hh "include/RHEJ/currents.hh" * \brief This is the a new class structure for currents. */ class CCurrent { public: CCurrent(COM sc0, COM sc1, COM sc2, COM sc3) :c0(sc0),c1(sc1),c2(sc2),c3(sc3) {}; CCurrent(const CLHEP::HepLorentzVector p) { c0=p.e(); c1=p.px(); c2=p.py(); c3=p.pz(); }; CCurrent() {}; CCurrent operator+(const CCurrent& other); CCurrent operator-(const CCurrent& other); CCurrent operator*(const double x); CCurrent operator*(const COM x); CCurrent operator/(const double x); CCurrent operator/(const COM x); friend std::ostream& operator<<(std::ostream& os, const CCurrent& cur); COM dot(CLHEP::HepLorentzVector p1); COM dot(CCurrent p1); COM c0,c1,c2,c3; private: }; /* std::ostream& operator <<(std::ostream& os, const CCurrent& cur); */ CCurrent operator * ( double x, CCurrent& m); CCurrent operator * ( COM x, CCurrent& m); CCurrent operator / ( double x, CCurrent& m); CCurrent operator / ( COM x, CCurrent& m); + +//! Current ??? +/** + * These functions are a mess. There are many more defined in the source file than declared in the + * header - and the arguments are mislabelled in some cases. Need to investigate. + */ +void j (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pin, bool helin,current &cur); + +//! Current ??? +/** + * These functions are a mess. There are many more defined in the source file than declared in the + * header - and the arguments are mislabelled in some cases. Need to investigate. + */ +void jio(HLV pin, bool helin, HLV pout, bool helout, current &cur); + +//! Current ??? +/** + * These functions are a mess. There are many more defined in the source file than declared in the + * header - and the arguments are mislabelled in some cases. Need to investigate. + */ +void joo(HLV pi, bool heli, HLV pj, bool helj, current &cur); + + //! Current ??? /** * These functions are a mess. There are many more defined in the source file than declared in the * header - and the arguments are mislabelled in some cases. Need to investigate. */ CCurrent j (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pin, bool helin); //! Current /** * These functions are a mess. There are many more defined in the source file than declared in the * header - and the arguments are mislabelled in some cases. Need to investigate. */ CCurrent jio (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pin, bool helin); //! Current /** * These functions are a mess. There are many more defined in the source file than declared in the * header - and the arguments are mislabelled in some cases. Need to investigate. */ CCurrent joo (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pin, bool helin); /* // Coupling values */ /* const double stw2 = 0.2222; */ /* const double ctw = sqrt(1.0 - stw2); */ /* const double gs = 1.217716; */ /* const double gw = 0.653232911; */ /* const double Zem = (-1.0 / 2.0 + stw2) / ctw; */ /* const double Zep = stw2 / ctw; */ /* const double Zum = ( 1.0 / 2.0 - 2.0 * stw2 / 3.0) / ctw; */ /* const double Zup = - 2.0 * stw2 / 3.0 / ctw; */ /* const double Zdm = (-1.0 / 2.0 + 1.0 / 3.0 * stw2) / ctw; */ /* const double Zdp = stw2 / 3.0 / ctw; */ /* const double RWeak = -pow(gw, 2.0); */ /* const double Strong = pow(gs, 4.0); */ /* const double ee = pow(gw, 2.0) * stw2; */ /* std::vector jMZqQ (HLV, HLV, HLV, HLV, HLV, HLV, std::vector , std::vector < std::vector >, int, int, bool, bool); */ /* std::vector jMZqg (HLV, HLV, HLV, HLV, HLV, HLV, std::vector , std::vector < std::vector >, int, int, bool, bool); */ /* void jZ (HLV, HLV, HLV, HLV, bool, bool, current); */ /* void jZbar (HLV, HLV, HLV, HLV, bool, bool, current); */ /* COM PZ(double); */ /* double Zq (int, bool); */ /* double Gq (int); */ + +inline COM cdot(const current & j1, const current & j2) +{ + return j1[0]*j2[0]-j1[1]*j2[1]-j1[2]*j2[2]-j1[3]*j2[3]; +} + +inline COM cdot(const HLV & p, const current & j1) { + return j1[0]*p.e()-j1[1]*p.x()-j1[2]*p.y()-j1[3]*p.z(); +} + +inline void cmult(const COM & factor, const current & j1, current &cur) +{ + cur[0]=factor*j1[0]; + cur[1]=factor*j1[1]; + cur[2]=factor*j1[2]; + cur[3]=factor*j1[3]; +} + +// WHY!?! +inline void cadd(const current & j1, const current & j2, const current & j3, + const current & j4, const current & j5, current &sum) +{ + sum[0]=j1[0]+j2[0]+j3[0]+j4[0]+j5[0]; + sum[1]=j1[1]+j2[1]+j3[1]+j4[1]+j5[1]; + sum[2]=j1[2]+j2[2]+j3[2]+j4[2]+j5[2]; + sum[3]=j1[3]+j2[3]+j3[3]+j4[3]+j5[3]; +} + +inline void cadd(const current & j1, const current & j2, const current & j3, + const current & j4, current &sum) { + sum[0] = j1[0] + j2[0] + j3[0] + j4[0]; + sum[1] = j1[1] + j2[1] + j3[1] + j4[1]; + sum[2] = j1[2] + j2[2] + j3[2] + j4[2]; + sum[3] = j1[3] + j2[3] + j3[3] + j4[3]; +} + +inline void cadd(const current & j1, const current & j2, const current & j3, + current &sum) +{ + sum[0]=j1[0]+j2[0]+j3[0]; + sum[1]=j1[1]+j2[1]+j3[1]; + sum[2]=j1[2]+j2[2]+j3[2]; + sum[3]=j1[3]+j2[3]+j3[3]; +} + +inline void cadd(const current & j1, const current & j2, current &sum) +{ + sum[0]=j1[0]+j2[0]; + sum[1]=j1[1]+j2[1]; + sum[2]=j1[2]+j2[2]; + sum[3]=j1[3]+j2[3]; +} + +inline double abs2(const COM & a) +{ + return (a*conj(a)).real(); +} + +inline double vabs2(const CCurrent & cur) +{ + return abs2(cur.c0)-abs2(cur.c1)-abs2(cur.c2)-abs2(cur.c3); +} + +inline double vre(const CCurrent & a, const CCurrent & b) +{ + return real(a.c0*conj(b.c0)-a.c1*conj(b.c1)-a.c2*conj(b.c2)-a.c3*conj(b.c3)); +} diff --git a/src/Tensor.cc b/src/Tensor.cc new file mode 100644 index 0000000..828c40b --- /dev/null +++ b/src/Tensor.cc @@ -0,0 +1,801 @@ +#include "RHEJ/currents.hh" +#include "RHEJ/Tensor.hh" + +#include + +#include + + + +namespace{ +// Tensor Template definitions + short int sigma_index5[1024]; + short int sigma_index3[64]; + std::valarray permfactor5; + std::valarray permfactor3; + short int helfactor5[2][1024]; + short int helfactor3[2][64]; + + //2D sigma matrices + const COM sigma0[2][2] = { {1.,0.}, {0.,1.}}; + const COM sigma1[2][2] = { {0.,1.}, {1.,0.}}; + const COM sigma2[2][2] = { {0,-1.*COM(0,1)}, {1.*COM(0,1),0}}; + const COM sigma3[2][2] = { {1.,0.}, {0.,-1.}}; + + Tensor<1,4> Sigma(int i, int j, bool hel){ + Tensor<1,4> newT; + if(hel){ + newT.components[0]=sigma0[i][j]; + newT.components[1]=sigma1[i][j]; + newT.components[2]=sigma2[i][j]; + newT.components[3]=sigma3[i][j]; + }else{ + newT.components[0]=sigma0[i][j]; + newT.components[1]=-sigma1[i][j]; + newT.components[2]=-sigma2[i][j]; + newT.components[3]=-sigma3[i][j]; + } + return newT; + } + + + //map from a list of 5 tensor lorentz indices onto a single index 0<=i<1024 in 4 dimensional spacetime + int tensor2listindex(std::array indexlist){ + int mu=indexlist[0]; + int nu=indexlist[1]; + int sigma=indexlist[2]; + int tau=indexlist[3]; + int rho=indexlist[4]; + int myindex; + + myindex = 256*mu+64*nu+16*sigma+4*tau+rho; + + if(myindex<0||myindex>1023){ + std::cerr<<"bad index in tensor2listindex "< indexlist){ + int mu=indexlist[0]; + int nu=indexlist[1]; + int sigma=indexlist[2]; + int myindex; + + myindex = 16*mu+4*nu+sigma; + + if(myindex<0||myindex>64){ + std::cerr<<"bad index in tensor2listindex "<> * perms){ + bool set_permfactor(true); + if(same4==0||diff==0) + set_permfactor=false; + + for(int diffpos=0;diffpos<5;diffpos++){ + std::array tempvec={same4,same4,same4,same4,same4}; + tempvec[diffpos]=diff; + perms->push_back(tempvec); + if(set_permfactor){ + if(diffpos%2==1) + permfactor5[tensor2listindex(tempvec)]=-1.; + } + } + } + + //generate all unique perms of vectors {a,a,a,b,b}, return in perms + //note, inital perm is always even + void perms32(int same3, int diff, std::vector> * perms){ + bool set_permfactor(true); + if(same3==0||diff==0) + set_permfactor=false; + + for(int diffpos1=0;diffpos1<5;diffpos1++){ + for(int diffpos2=diffpos1+1;diffpos2<5;diffpos2++){ + std::array tempvec={same3,same3,same3,same3,same3}; + tempvec[diffpos1]=diff; + tempvec[diffpos2]=diff; + perms->push_back(tempvec); + if(set_permfactor){ + if((diffpos2-diffpos1)%2==0) + permfactor5[tensor2listindex(tempvec)]=-1.; + } + } + } + } + + //generate all unique perms of vectors {a,a,a,b,c}, return in perms + //we have two bools since there are three distinct type of sigma matrices to permute, so need to test if the 3xrepeated = sigma0 + //or if one of the singles is sigma0 + //if diff1/diff2 are distinct, flipping them results in a change of perm, otherwise it'll be symmetric under flip -> encode this in set_permfactor2 + //as long as diff2!=0 can ensure inital perm is even + //if diff2=0 then it is not possible to ensure inital perm even -> encode in bool signflip + void perms311(int same3, int diff1, int diff2, std::vector> * perms){ + bool set_permfactor2(true); + bool same0(false); + bool diff0(false); + bool signflip(false); //if true, inital perm is odd + + if(same3==0) //is the repeated matrix sigma0? + same0 = true; + else if(diff2==0){ //is one of the single matrices sigma0 + diff0=true; + if((diff1%3-same3)!=-1) + signflip=true; + } + else if(diff1==0){ + std::cerr<<"Note, only first and last argument may be zero"< tempvec={same3,same3,same3,same3,same3}; + tempvec[diffpos1]=diff1; + tempvec[diffpos2]=diff2; + perms->push_back(tempvec); + + if(!same0&&!diff0){//full antisymmetric under exchange of same3,diff1,diff2 + if((diffpos2-diffpos1)%2==0){ + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1); //odd perm + set_permfactor2=false; //if this perm is odd, swapping diff1<->diff2 automatically even + }else{ + permfactor5[tensor2listindex(tempvec)]=COM(0,1); //even perm + set_permfactor2=true; //if this perm is even, swapping diff1<->diff2 automatically odd + } + }else if(diff0){//one of the single matrices is sigma0 + if(signflip){ //initial config is odd! + if(diffpos1%2==1){ + permfactor5[tensor2listindex(tempvec)]=COM(0,1); //even perm + //initally symmetric under diff1<->diff2 => + set_permfactor2=false; //if this perm is even, automatically even for first diffpos2 + }else{ + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1); //odd perm + //initally symmetric under diff1<->diff2 => + set_permfactor2=true; //if this perm is odd, automatically odd for first diffpos2 + } + }else{//diff0=true, initial config is even + if(diffpos1%2==1){ + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1); //odd perm + //initally symmetric under diff1<->diff2 => + set_permfactor2=true; //if this perm is odd, automatically odd for first diffpos2 + } + else{ + permfactor5[tensor2listindex(tempvec)]=COM(0,1); //even perm + //initally symmetric under diff1<->diff2 => + set_permfactor2=false; //if this perm is even, automatically even for first diffpos2 + } + } + if((diffpos2-diffpos1-1)%2==1) + set_permfactor2=!set_permfactor2; //change to account for diffpos2 + }else if(same0){//the repeated matrix is sigma0 => only relative positions of diff1, diff2 matter. + permfactor5[tensor2listindex(tempvec)]=COM(0,1); //always even before flip because diff1posdiff2 automatically odd + } + + tempvec[diffpos1]=diff2; + tempvec[diffpos2]=diff1; + perms->push_back(tempvec); + + if(set_permfactor2) + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1); + + else + permfactor5[tensor2listindex(tempvec)]=COM(0,1); + + } + } + + } + + //generate all unique perms of vectors {a,a,b,b,c}, return in perms + void perms221(int same2a, int same2b, int diff, std::vector> * perms){ + bool set_permfactor1(true); + bool set_permfactor2(true); + if(same2b==0){ + std::cerr<<"second entry in perms221() shouldn't be zero" < tempvec={same2a,same2a,same2a,same2a,same2a}; + tempvec[samepos]=same2b; + tempvec[samepos2]=same2b; + tempvec[diffpos]=diff; + perms->push_back(tempvec); + + if(set_permfactor1){ + if(set_permfactor2){//full anti-symmetry + if(permcount%2==1) + permfactor5[tensor2listindex(tempvec)]=-1.; + }else{ //diff is sigma0 + if(((samepos2-samepos-1)%3>0)&&(abs(abs(samepos2-diffpos)-abs(samepos-diffpos))%3>0)) + permfactor5[tensor2listindex(tempvec)]=-1.; + } + }else{ //same2a is sigma0 + if((diffpos>samepos)&&(diffpos> * perms){ + bool twozero(false); + if(same2==0) + twozero=true; + else if (diff1!=0){ + std::cerr<<"One of first or second argurments must be a zero"< tempvec={same2,same2,same2,same2,same2}; + tempvec[diffpos1]=diff1; + tempvec[diffpos2]=diff2; + tempvec[diffpos3]=diff3; + perms->push_back(tempvec); + + if(twozero){//don't care about exact positions of singles, just order + if(diffpos2>diffpos3&&diffpos3>diffpos1) + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1);//odd + else if(diffpos1>diffpos2&&diffpos2>diffpos3) + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1);//odd + else if(diffpos3>diffpos1&&diffpos1>diffpos2) + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1);//odd + else + permfactor5[tensor2listindex(tempvec)]=COM(0,1);//evwn + }else{ + if(permcount%2==1) + permfactor5[tensor2listindex(tempvec)]=-1.*COM(0,1); + else + permfactor5[tensor2listindex(tempvec)]=COM(0,1); + } + permcount++; + + } + } + } + } + + void perms21(int same, int diff, std::vector> * perms){ + + bool set_permfactor(true); + if(same==0||diff==0) + set_permfactor=false; + + + for(int diffpos=0; diffpos<3;diffpos++){ + std::array tempvec={same,same,same}; + tempvec[diffpos]=diff; + perms->push_back(tempvec); + if(set_permfactor&&diffpos==1) + permfactor3[tensor2listindex(tempvec)]=-1.; + } + + } + + void perms111(int diff1, int diff2, int diff3, std::vector> * perms){ + bool sig_zero(false); + if(diff1==0) + sig_zero=true; + else if(diff2==0||diff3==0){ + std::cerr<<"Only first argument may be a zero."< tempvec={diff1,diff1,diff1}; + tempvec[pos1]=diff2; + tempvec[pos2]=diff3; + perms->push_back(tempvec); + if(sig_zero){ + permfactor3[tensor2listindex(tempvec)]=1.*COM(0,1); //even + }else if(permcount%2==1){ + permfactor3[tensor2listindex(tempvec)]=-1.*COM(0,1); //odd + }else{ + permfactor3[tensor2listindex(tempvec)]=1.*COM(0,1); //even + } + + tempvec[pos1]=diff3; + tempvec[pos2]=diff2; + perms->push_back(tempvec); + + if(sig_zero){ + permfactor3[tensor2listindex(tempvec)]=-1.*COM(0,1); //odd + }else if(permcount%2==1){ + permfactor3[tensor2listindex(tempvec)]=1.*COM(0,1); //even + }else{ + permfactor3[tensor2listindex(tempvec)]=-1.*COM(0,1); //odd + } + permcount++; + } + + } + + } + + +void SpinorO(CLHEP::HepLorentzVector p, bool hel, COM *sp){ + //sp is pointer to COM sp[2] + COM pplus = p.e() +p.z(); + COM pminus = p.e() -p.z(); + COM sqpp= sqrt(pplus); + COM sqpm= sqrt(pminus); + COM pperp = p.x() + COM(0,1)*p.y(); + + //if hel=+ + if(hel){ + sp[0] = sqpp; + sp[1] = sqpm*pperp/abs(pperp); + }else{ + sp[0] = sqpm*conj(pperp)/abs(pperp); + sp[1] = -sqpp; + } +} + +void SpinorIp(COM sqpp, bool hel, COM *sp){ + //if hel=+ + if(hel){ + sp[0] = sqpp; + sp[1] = 0.; + }else{ + sp[0] = 0.; + sp[1] = -sqpp; + } +} + +void SpinorIm(COM sqpm, bool hel, COM *sp){ + //if hel=+ + if(hel){ + sp[0] = 0; + sp[1] = -sqpm; + }else{ + sp[0] = -sqpm; + sp[1] = 0.; + } +} + + +void Spinor(CLHEP::HepLorentzVector p, bool hel, COM *sp){ + COM pplus = p.e() +p.z(); + COM pminus = p.e() -p.z(); + + //If incoming along +ve z + if (pminus==0.){ + COM sqpp= sqrt(pplus); + SpinorIp(sqpp,hel,sp); + } + //If incoming along -ve z + else if(pplus==0.){ + COM sqpm= sqrt(pminus); + SpinorIm(sqpm,hel,sp); + } + //Outgoing + else{ + SpinorO(p,hel,sp); + } +} +} // anonymous namespace + +Tensor<2,4> Metric(void){ + Tensor<2,4> g(0.); + g.Set(0,0, 1.); + g.Set(1,1, -1.); + g.Set(2,2, -1.); + g.Set(3,3, -1.); + return g; +} + +//<1|mu|2> +Tensor<1,4> TCurrent(CLHEP::HepLorentzVector p1, bool h1,CLHEP::HepLorentzVector p2, bool h2){ + COM sp1[2]; + COM sp2[2]; + Tensor<1,4> newT(0.); + + CLHEP::HepLorentzVector p1new=p1; + CLHEP::HepLorentzVector p2new=p2; + + if(p1.e()<0){ + p1new=-p1; + } + + if(p2.e()<0){ + p2new=-p2; + } + + if(h1!=h2){ + return newT; + } + + Spinor(p1new, h1, sp1); + Spinor(p2new, h2, sp2); + + for(int i=0;i<2;i++){ + for(int j=0; j<2; j++){ + newT+=(Sigma(i,j,h2)*sp2[j])*conj(sp1[i]); + } + } + return newT; +} +//<1|mu nu sigma|2> +Tensor<3,4> T3Current(CLHEP::HepLorentzVector p1, bool h1,CLHEP::HepLorentzVector p2, bool h2){ + + COM sp1[2]; + COM sp2[2]; + + Tensor<3,4> newT(0.); + + CLHEP::HepLorentzVector p1new=p1; + CLHEP::HepLorentzVector p2new=p2; + + if(p1.e()<0){ + p1new=-p1; + } + + if(p2.e()<0){ + p2new=-p2; + } + + if(h1!=h2){ + return newT; + } + + Spinor(p1new, h1, sp1); + Spinor(p2new, h2, sp2); + + + COM current[4]; + + for(int i=0; i<2;i++){ + for(int j=0; j<2;j++){ + current[0]+=conj(sp1[i])*sigma0[i][j]*sp2[j]; + current[1]+=conj(sp1[i])*sigma1[i][j]*sp2[j]; + current[2]+=conj(sp1[i])*sigma2[i][j]*sp2[j]; + current[3]+=conj(sp1[i])*sigma3[i][j]*sp2[j]; + } + } + + for(int itensor=0;itensor +Tensor<5,4> T5Current(CLHEP::HepLorentzVector p1, bool h1,CLHEP::HepLorentzVector p2, bool h2){ + + COM sp1[2]; + COM sp2[2]; + + Tensor<5,4> newT(0.); + + CLHEP::HepLorentzVector p1new=p1; + CLHEP::HepLorentzVector p2new=p2; + + if(p1.e()<0){ + p1new=-p1; + } + + if(p2.e()<0){ + p2new=-p2; + } + + if(h1!=h2){ + return newT; + } + + Spinor(p1new, h1, sp1); + Spinor(p2new, h2, sp2); + + + COM current[4]; + + for(int i=0; i<2;i++){ + for(int j=0; j<2;j++){ + current[0]+=conj(sp1[i])*sigma0[i][j]*sp2[j]; + current[1]+=conj(sp1[i])*sigma1[i][j]*sp2[j]; + current[2]+=conj(sp1[i])*sigma2[i][j]*sp2[j]; + current[3]+=conj(sp1[i])*sigma3[i][j]*sp2[j]; + } + } + + for(int itensor=0;itensor Construct1Tensor(CCurrent j){ + Tensor<1,4> newT; + newT.components={j.c0,j.c1,j.c2,j.c3}; + return newT; +} + +Tensor<1,4> Construct1Tensor(CLHEP::HepLorentzVector p){ + Tensor<1,4> newT; + newT.components={p.e(),p.x(),p.y(),p.z()}; + return newT; +} + +Tensor<1,4> eps(CLHEP::HepLorentzVector k, CLHEP::HepLorentzVector ref, bool pol){ + + Tensor<1,4> polvec; + COM spk[2]; + COM spr[2]; + COM denom; + + CLHEP::HepLorentzVector knew=k; + + if(k.e()<0){ + knew=-k; + } + + Spinor(knew, pol, spk); + Spinor(ref, !pol, spr); + denom = pow(-1.,pol)*sqrt(2)*(conj(spr[0])*spk[0] + conj(spr[1])*spk[1]); + polvec = TCurrent(ref,!pol,knew,!pol)/denom; + + return polvec; +} + + //slow function! - but only need to evaluate once. + bool init_sigma_index(void) + { + + //initialize permfactor(3) to list of ones (change to minus one for each odd permutation + //and multiply by i for all permutations in perms2111, perms311, perms111) + permfactor5.resize(1024,1.); + permfactor3.resize(64,1.); + + //first set sigma_index (5) + std::vector> sigma0indices; + std::vector> sigma1indices; + std::vector> sigma2indices; + std::vector> sigma3indices; + + //need to generate all possible permuations of {i,j,k,l,m} + //where each index can be {0,1,2,3,4} + //1024 possibilities + + //perms with 5 same + sigma0indices.push_back({0,0,0,0,0}); + sigma1indices.push_back({1,1,1,1,1}); + sigma2indices.push_back({2,2,2,2,2}); + sigma3indices.push_back({3,3,3,3,3}); + + //perms with 4 same + perms41(1,0,&sigma0indices); + perms41(2,0,&sigma0indices); + perms41(3,0,&sigma0indices); + perms41(0,1,&sigma1indices); + perms41(2,1,&sigma1indices); + perms41(3,1,&sigma1indices); + perms41(0,2,&sigma2indices); + perms41(1,2,&sigma2indices); + perms41(3,2,&sigma2indices); + perms41(0,3,&sigma3indices); + perms41(1,3,&sigma3indices); + perms41(2,3,&sigma3indices); + + //perms with 3 same, 2 same + perms32(0,1,&sigma0indices); + perms32(0,2,&sigma0indices); + perms32(0,3,&sigma0indices); + perms32(1,0,&sigma1indices); + perms32(1,2,&sigma1indices); + perms32(1,3,&sigma1indices); + perms32(2,0,&sigma2indices); + perms32(2,1,&sigma2indices); + perms32(2,3,&sigma2indices); + perms32(3,0,&sigma3indices); + perms32(3,1,&sigma3indices); + perms32(3,2,&sigma3indices); + + //perms with 3 same, 2 different + perms311(1,2,3,&sigma0indices); + perms311(2,3,1,&sigma0indices); + perms311(3,1,2,&sigma0indices); + perms311(0,2,3,&sigma1indices); + perms311(2,3,0,&sigma1indices); + perms311(3,2,0,&sigma1indices); + perms311(0,3,1,&sigma2indices); + perms311(1,3,0,&sigma2indices); + perms311(3,1,0,&sigma2indices); + perms311(0,1,2,&sigma3indices); + perms311(1,2,0,&sigma3indices); + perms311(2,1,0,&sigma3indices); + + perms221(1,2,0,&sigma0indices); + perms221(1,3,0,&sigma0indices); + perms221(2,3,0,&sigma0indices); + perms221(0,2,1,&sigma1indices); + perms221(0,3,1,&sigma1indices); + perms221(2,3,1,&sigma1indices); + perms221(0,1,2,&sigma2indices); + perms221(0,3,2,&sigma2indices); + perms221(1,3,2,&sigma2indices); + perms221(0,1,3,&sigma3indices); + perms221(0,2,3,&sigma3indices); + perms221(1,2,3,&sigma3indices); + + perms2111(0,1,2,3,&sigma0indices); + perms2111(1,0,2,3,&sigma1indices); + perms2111(2,0,3,1,&sigma2indices); + perms2111(3,0,1,2,&sigma3indices); + + if(sigma0indices.size()!=256){ + std::cerr<<"sigma_index not set: "; + std::cerr<<"sigma0indices has "<< sigma0indices.size() << " components" << std::endl; + return false; + } + else if(sigma1indices.size()!=256){ + std::cerr<<"sigma_index not set: "; + std::cerr<<"sigma1indices has "<< sigma0indices.size() << " components" << std::endl; + return false; + } + else if(sigma2indices.size()!=256){ + std::cerr<<"sigma_index not set: "; + std::cerr<<"sigma2indices has "<< sigma0indices.size() << " components" << std::endl; + return false; + } + else if(sigma3indices.size()!=256){ + std::cerr<<"sigma_index not set: "; + std::cerr<<"sigma3indices has "<< sigma0indices.size() << " components" << std::endl; + return false; + } + + for(int i=0;i<256;i++){ + //map each unique set of tensor indices to its position in a list + int index0 = tensor2listindex(sigma0indices.at(i)); + int index1 = tensor2listindex(sigma1indices.at(i)); + int index2 = tensor2listindex(sigma2indices.at(i)); + int index3 = tensor2listindex(sigma3indices.at(i)); + sigma_index5[index0]=0; + sigma_index5[index1]=1; + sigma_index5[index2]=2; + sigma_index5[index3]=3; + + short int sign[4]={1,-1,-1,-1}; + //plus->true->1 + helfactor5[1][index0]=sign[sigma0indices.at(i)[1]]*sign[sigma0indices.at(i)[3]]; + helfactor5[1][index1]=sign[sigma1indices.at(i)[1]]*sign[sigma1indices.at(i)[3]]; + helfactor5[1][index2]=sign[sigma2indices.at(i)[1]]*sign[sigma2indices.at(i)[3]]; + helfactor5[1][index3]=sign[sigma3indices.at(i)[1]]*sign[sigma3indices.at(i)[3]]; + //minus->false->0 + helfactor5[0][index0]=sign[sigma0indices.at(i)[0]]*sign[sigma0indices.at(i)[2]]*sign[sigma0indices.at(i)[4]]; + helfactor5[0][index1]=sign[sigma1indices.at(i)[0]]*sign[sigma1indices.at(i)[2]]*sign[sigma1indices.at(i)[4]]; + helfactor5[0][index2]=sign[sigma2indices.at(i)[0]]*sign[sigma2indices.at(i)[2]]*sign[sigma2indices.at(i)[4]]; + helfactor5[0][index3]=sign[sigma3indices.at(i)[0]]*sign[sigma3indices.at(i)[2]]*sign[sigma3indices.at(i)[4]]; + + } + + //now set sigma_index3 + std::vector> sigma0indices3; + std::vector> sigma1indices3; + std::vector> sigma2indices3; + std::vector> sigma3indices3; + + //perms with 3 same + sigma0indices3.push_back({0,0,0}); + sigma1indices3.push_back({1,1,1}); + sigma2indices3.push_back({2,2,2}); + sigma3indices3.push_back({3,3,3}); + + //2 same + perms21(1,0,&sigma0indices3); + perms21(2,0,&sigma0indices3); + perms21(3,0,&sigma0indices3); + perms21(0,1,&sigma1indices3); + perms21(2,1,&sigma1indices3); + perms21(3,1,&sigma1indices3); + perms21(0,2,&sigma2indices3); + perms21(1,2,&sigma2indices3); + perms21(3,2,&sigma2indices3); + perms21(0,3,&sigma3indices3); + perms21(1,3,&sigma3indices3); + perms21(2,3,&sigma3indices3); + + //none same + perms111(1,2,3,&sigma0indices3); + perms111(0,2,3,&sigma1indices3); + perms111(0,3,1,&sigma2indices3); + perms111(0,1,2,&sigma3indices3); + + if(sigma0indices3.size()!=16){ + std::cerr<<"sigma_index3 not set: "; + std::cerr<<"sigma0indices3 has "<< sigma0indices3.size() << " components" << std::endl; + return false; + } + else if(sigma1indices3.size()!=16){ + std::cerr<<"sigma_index3 not set: "; + std::cerr<<"sigma1indices3 has "<< sigma0indices3.size() << " components" << std::endl; + return false; + } + else if(sigma2indices3.size()!=16){ + std::cerr<<"sigma_index3 not set: "; + std::cerr<<"sigma2indices3 has "<< sigma0indices3.size() << " components" << std::endl; + return false; + } + else if(sigma3indices3.size()!=16){ + std::cerr<<"sigma_index3 not set: "; + std::cerr<<"sigma3indices3 has "<< sigma0indices3.size() << " components" << std::endl; + return false; + } + + + for(int i=0;i<16;i++){ + int index0 = tensor2listindex(sigma0indices3.at(i)); + int index1 = tensor2listindex(sigma1indices3.at(i)); + int index2 = tensor2listindex(sigma2indices3.at(i)); + int index3 = tensor2listindex(sigma3indices3.at(i)); + sigma_index3[index0]=0; + sigma_index3[index1]=1; + sigma_index3[index2]=2; + sigma_index3[index3]=3; + + short int sign[4]={1,-1,-1,-1}; + //plus->true->1 + helfactor3[1][index0]=sign[sigma0indices3.at(i)[1]]; + helfactor3[1][index1]=sign[sigma1indices3.at(i)[1]]; + helfactor3[1][index2]=sign[sigma2indices3.at(i)[1]]; + helfactor3[1][index3]=sign[sigma3indices3.at(i)[1]]; + //minus->false->0 + helfactor3[0][index0]=sign[sigma0indices3.at(i)[0]]*sign[sigma0indices3.at(i)[2]]; + helfactor3[0][index1]=sign[sigma1indices3.at(i)[0]]*sign[sigma1indices3.at(i)[2]]; + helfactor3[0][index2]=sign[sigma2indices3.at(i)[0]]*sign[sigma2indices3.at(i)[2]]; + helfactor3[0][index3]=sign[sigma3indices3.at(i)[0]]*sign[sigma3indices3.at(i)[2]]; + + } + + //std::cout<<"sigma_index_set!!"< + +#include + + + +namespace { // Helper Functions + // FKL W Helper Functions + void jW (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pe, bool hele, CLHEP::HepLorentzVector pnu, bool helnu, CLHEP::HepLorentzVector pin, bool helin, current cur) + { + // NOTA BENE: Conventions for W+ --> e+ nu, so that nu is lepton(6), e is anti-lepton(5) + // Need to swap e and nu for events with W- --> e- nubar! + if (helin==helout && hele==helnu) { + CLHEP::HepLorentzVector qa=pout+pe+pnu; + CLHEP::HepLorentzVector qb=pin-pe-pnu; + double ta(qa.m2()),tb(qb.m2()); + + current t65,vout,vin,temp2,temp3,temp5; + joo(pnu,helnu,pe,hele,t65); + vout[0]=pout.e(); + vout[1]=pout.x(); + vout[2]=pout.y(); + vout[3]=pout.z(); + vin[0]=pin.e(); + vin[1]=pin.x(); + vin[2]=pin.y(); + vin[3]=pin.z(); + + COM brac615=cdot(t65,vout); + COM brac645=cdot(t65,vin); + + // prod1565 and prod6465 are zero for Ws (not Zs)!! + joo(pout,helout,pnu,helout,temp2); + COM prod1665=cdot(temp2,t65); + j(pe,helin,pin,helin,temp3); + COM prod5465=cdot(temp3,t65); + + joo(pout,helout,pe,helout,temp2); + j(pnu,helnu,pin,helin,temp3); + j(pout,helout,pin,helin,temp5); + + current term1,term2,term3,sum; + cmult(2.*brac615/ta+2.*brac645/tb,temp5,term1); + cmult(prod1665/ta,temp3,term2); + cmult(-prod5465/tb,temp2,term3); + + cadd(term1,term2,term3,sum); + + cur[0]=sum[0]; + cur[1]=sum[1]; + cur[2]=sum[2]; + cur[3]=sum[3]; + } + } + + void jWbar (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pe, bool hele, CLHEP::HepLorentzVector pnu, bool helnu, CLHEP::HepLorentzVector pin, bool helin, current cur) + { + // NOTA BENE: Conventions for W+ --> e+ nu, so that nu is lepton(6), e is anti-lepton(5) + // Need to swap e and nu for events with W- --> e- nubar! + if (helin==helout && hele==helnu) { + CLHEP::HepLorentzVector qa=pout+pe+pnu; + CLHEP::HepLorentzVector qb=pin-pe-pnu; + double ta(qa.m2()),tb(qb.m2()); + + current t65,vout,vin,temp2,temp3,temp5; + joo(pnu,helnu,pe,hele,t65); + vout[0]=pout.e(); + vout[1]=pout.x(); + vout[2]=pout.y(); + vout[3]=pout.z(); + vin[0]=pin.e(); + vin[1]=pin.x(); + vin[2]=pin.y(); + vin[3]=pin.z(); + + COM brac615=cdot(t65,vout); + COM brac645=cdot(t65,vin); + + // prod1565 and prod6465 are zero for Ws (not Zs)!! + joo(pe,helout,pout,helout,temp2); // temp2 is <5|alpha|1> + COM prod5165=cdot(temp2,t65); + jio(pin,helin,pnu,helin,temp3); // temp3 is <4|alpha|6> + COM prod4665=cdot(temp3,t65); + + joo(pnu,helout,pout,helout,temp2); // temp2 is now <6|mu|1> + jio(pin,helin,pe,helin,temp3); // temp3 is now <4|mu|5> + jio(pin,helin,pout,helout,temp5); // temp5 is <4|mu|1> + + current term1,term2,term3,sum; + cmult(-2.*brac615/ta-2.*brac645/tb,temp5,term1); + cmult(-prod5165/ta,temp3,term2); + cmult(prod4665/tb,temp2,term3); + + cadd(term1,term2,term3,sum); + + cur[0]=sum[0]; + cur[1]=sum[1]; + cur[2]=sum[2]; + cur[3]=sum[3]; + } + } + +CCurrent jW (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pe, bool hele, CLHEP::HepLorentzVector pnu, bool helnu, CLHEP::HepLorentzVector pin, bool helin) +{ + + COM cur[4]; + + cur[0]=0.; + cur[1]=0.; + cur[2]=0.; + cur[3]=0.; + CCurrent sum(0.,0.,0.,0.); + + // NOTA BENE: Conventions for W+ --> e+ nu, so that nu is lepton(6), e is anti-lepton(5) + // Need to swap e and nu for events with W- --> e- nubar! + if (helin==helout && hele==helnu) { + CLHEP::HepLorentzVector qa=pout+pe+pnu; + CLHEP::HepLorentzVector qb=pin-pe-pnu; + double ta(qa.m2()),tb(qb.m2()); + + CCurrent temp2,temp3,temp5; + CCurrent t65 = joo(pnu,helnu,pe,hele); + CCurrent vout(pout.e(),pout.x(),pout.y(),pout.z()); + CCurrent vin(pin.e(),pin.x(),pin.y(),pin.z()); + + COM brac615=t65.dot(vout); + COM brac645=t65.dot(vin); + + + // prod1565 and prod6465 are zero for Ws (not Zs)!! + temp2 = joo(pout,helout,pnu,helout); + COM prod1665=temp2.dot(t65); + temp3 = j(pe,helin,pin,helin); + COM prod5465=temp3.dot(t65); + + temp2=joo(pout,helout,pe,helout); + temp3=j(pnu,helnu,pin,helin); + temp5=j(pout,helout,pin,helin); + + CCurrent term1,term2,term3; + term1=(2.*brac615/ta+2.*brac645/tb)*temp5; + term2=(prod1665/ta)*temp3; + term3=(-prod5465/tb)*temp2; + + sum=term1+term2+term3; + } + + return sum; +} + +CCurrent jWbar (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pe, bool hele, CLHEP::HepLorentzVector pnu, bool helnu, CLHEP::HepLorentzVector pin, bool helin) +{ + + COM cur[4]; + + cur[0]=0.; + cur[1]=0.; + cur[2]=0.; + cur[3]=0.; + CCurrent sum(0.,0.,0.,0.); + + // NOTA BENE: Conventions for W+ --> e+ nu, so that nu is lepton(6), e is anti-lepton(5) + // Need to swap e and nu for events with W- --> e- nubar! + if (helin==helout && hele==helnu) { + CLHEP::HepLorentzVector qa=pout+pe+pnu; + CLHEP::HepLorentzVector qb=pin-pe-pnu; + double ta(qa.m2()),tb(qb.m2()); + + CCurrent temp2,temp3,temp5; + CCurrent t65 = joo(pnu,helnu,pe,hele); + CCurrent vout(pout.e(),pout.x(),pout.y(),pout.z()); + CCurrent vin(pin.e(),pin.x(),pin.y(),pin.z()); + + COM brac615=t65.dot(vout); + COM brac645=t65.dot(vin); + + // prod1565 and prod6465 are zero for Ws (not Zs)!! + temp2 = joo(pe,helout,pout,helout); // temp2 is <5|alpha|1> + COM prod5165=temp2.dot(t65); + temp3 = jio(pin,helin,pnu,helin); // temp3 is <4|alpha|6> + COM prod4665=temp3.dot(t65); + + temp2=joo(pnu,helout,pout,helout); // temp2 is now <6|mu|1> + temp3=jio(pin,helin,pe,helin); // temp3 is now <4|mu|5> + temp5=jio(pin,helin,pout,helout); // temp5 is <4|mu|1> + + CCurrent term1,term2,term3; + term1 =(-2.*brac615/ta-2.*brac645/tb)*temp5; + term2 =(-prod5165/ta)*temp3; + term3 =(prod4665/tb)*temp2; + + sum = term1 + term2 + term3; + } + + return sum; +} + + // Relevant W+Jets Unordered Contribution Helper Functions + // W+Jets Uno + double jM2Wuno(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1,CLHEP::HepLorentzVector plbar, CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pa, bool h1, CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector pb, bool h2, bool pol) + { + static bool is_sigma_index_set(false); + + if(!is_sigma_index_set){ + //std::cout<<"Setting sigma_index...." << std::endl; + if(init_sigma_index()) + is_sigma_index_set = true; + else + return 0.; + } + + CLHEP::HepLorentzVector pW = pl+plbar; + CLHEP::HepLorentzVector q1g=pa-pW-p1-pg; + CLHEP::HepLorentzVector q1 = pa-p1-pW; + CLHEP::HepLorentzVector q2 = p2-pb; + + double taW=(pa-pW).m2(); + double taW1=(pa-pW-p1).m2(); + double tb2=(pb-p2).m2(); + double tb2g=(pb-p2-pg).m2(); + double s1W=(p1+pW).m2(); + double s1gW=(p1+pW+pg).m2(); + double s1g=(p1+pg).m2(); + double tag=(pa-pg).m2(); + double taWg=(pa-pW-pg).m2(); + double ca =3.; + double cf =4./3.; + + //use p1 as ref vec in pol tensor + Tensor<1,4> epsg = eps(pg,p2,pol); + Tensor<1,4> epsW = TCurrent(pl,false,plbar,false); + Tensor<1,4> j2b = TCurrent(p2,h2,pb,h2); + + Tensor<1,4> Tq1q2 = Construct1Tensor((q1+q2)/taW1 + (pb/pb.dot(pg)+ p2/p2.dot(pg))*tb2/(2*tb2g)); + Tensor<1,4> Tq1g = Construct1Tensor((-pg-q1))/taW1; + Tensor<1,4> Tq2g = Construct1Tensor((pg-q2)); + Tensor<1,4> TqaW = Construct1Tensor((pa-pW));//pa-pw + Tensor<1,4> Tqag = Construct1Tensor((pa-pg)); + Tensor<1,4> TqaWg = Construct1Tensor((pa-pg-pW)); + Tensor<1,4> Tp1g = Construct1Tensor((p1+pg)); + Tensor<1,4> Tp1W = Construct1Tensor((p1+pW));//p1+pw + Tensor<1,4> Tp1gW = Construct1Tensor((p1+pg+pW));//p1+pw+pg + + Tensor<2,4> g=Metric(); + + Tensor<3,4> J31a = T3Current(p1, h1, pa, h1); + Tensor<2,4> J2_qaW =J31a.contract(TqaW/taW, 2); + Tensor<2,4> J2_p1W =J31a.contract(Tp1W/s1W, 2); + Tensor<3,4> L1a =J2_qaW.leftprod(Tq1q2); + Tensor<3,4> L1b =J2_p1W.leftprod(Tq1q2); + Tensor<3,4> L2a = J2_qaW.leftprod(Tq1g); + Tensor<3,4> L2b = J2_p1W.leftprod(Tq1g); + Tensor<3,4> L3 = (g.rightprod(J2_qaW.contract(Tq2g,1)+J2_p1W.contract(Tq2g,2)))/taW1; + Tensor<3,4> L(0.); + + Tensor<5,4> J51a = T5Current(p1, h1, pa, h1); + + Tensor<4,4> J_qaW = J51a.contract(TqaW,4); + Tensor<4,4> J_qag = J51a.contract(Tqag,4); + Tensor<4,4> J_p1gW = J51a.contract(Tp1gW,4); + + Tensor<3,4> U1a = J_qaW.contract(Tp1g,2); + Tensor<3,4> U1b = J_p1gW.contract(Tp1g,2); + Tensor<3,4> U1c = J_p1gW.contract(Tp1W,2); + Tensor<3,4> U1(0.); + + Tensor<3,4> U2a = J_qaW.contract(TqaWg,2); + Tensor<3,4> U2b = J_qag.contract(TqaWg,2); + Tensor<3,4> U2c = J_qag.contract(Tp1W,2); + Tensor<3,4> U2(0.); + + for(int nu=0; nu<4;nu++){ + for(int mu=0;mu<4;mu++){ + for(int rho=0;rho<4;rho++){ + L.Set(nu,mu,rho,L1a.at(nu,mu,rho)+L1b.at(nu,rho,mu)+L2a.at(mu,nu,rho)+L2b.at(mu,rho,nu)+L3.at(mu,nu,rho)); + U1.Set(nu,mu,rho, U1a.at(nu,mu,rho)/(s1g*taW) + U1b.at(nu,rho,mu)/(s1g*s1gW) + U1c.at(rho,nu,mu)/(s1W*s1gW)); + U2.Set(nu,mu,rho,U2a.at(mu,nu,rho)/(taWg*taW) + U2b.at(mu,rho,nu)/(taWg*tag) + U2c.at(rho,mu,nu)/(s1W*tag)); + } + } + } + + COM X = ((((U1-L).contract(epsW,3)).contract(j2b,2)).contract(epsg,1)).at(0); + COM Y = ((((U2+L).contract(epsW,3)).contract(j2b,2)).contract(epsg,1)).at(0); + + double amp = ca*cf*cf/2.*(norm(X)+norm(Y)) - cf/2.*(X*conj(Y)).real(); + + double t1 = q1g.m2(); + double t2 = q2.m2(); + + //Divide by t-channels + amp/=(t1*t2); + + //Average over initial states + amp/=(4.*ca*ca); + + return amp; + } + + + + // Relevant Wqqx Helper Functions. + //g->qxqlxl (Calculates gluon to qqx Current. See JV_\mu in WSubleading Notes) + Tensor <1,4> gtqqxW(CLHEP::HepLorentzVector pq,CLHEP::HepLorentzVector pqbar,CLHEP::HepLorentzVector pl,CLHEP::HepLorentzVector plbar){ + + double s2AB=(pl+plbar+pq).m2(); + double s3AB=(pl+plbar+pqbar).m2(); + + Tensor<1,4> Tpq = Construct1Tensor(pq); + Tensor<1,4> Tpqbar = Construct1Tensor(pqbar); + Tensor<1,4> TAB = Construct1Tensor(pl+plbar); + + // Define llx current. Note factor of 2 to account for sqrt(2) on each W vertex + Tensor<1,4> ABCur = TCurrent(pl, false, plbar, false)/2; + + //blank 3 Gamma Current + Tensor<3,4> JV23 = T3Current(pq,false,pqbar,false); + + // Components of g->qqW before W Contraction + Tensor<2,4> JV1 = JV23.contract((Tpq + TAB),2)/(s2AB); + Tensor<2,4> JV2 = JV23.contract((Tpqbar + TAB),2)/(s3AB); + + // g->qqW Current. Note Minus between terms due to momentum flow. + // Also note: (-I)^2 from W vert. (I) from Quark prop. + Tensor<1,4> JVCur = (JV1.contract(ABCur,1) - JV2.contract(ABCur,2))*COM(0.,-1.); + + return JVCur; + } + + // Helper Functions Calculate the Crossed Contribution + Tensor <2,4> MCrossW(CLHEP::HepLorentzVector pa,CLHEP::HepLorentzVector p1,CLHEP::HepLorentzVector pb,CLHEP::HepLorentzVector p4, CLHEP::HepLorentzVector pq,CLHEP::HepLorentzVector pqbar,CLHEP::HepLorentzVector pl,CLHEP::HepLorentzVector plbar, std::vector partons, int nabove){ + + // Useful propagator factors + double s2AB=(pl+plbar+pq).m2(); + double s3AB=(pl+plbar+pqbar).m2(); + + CLHEP::HepLorentzVector q1, q3; + q1=pa; + for(int i=0; i Tp1 = Construct1Tensor(p1); + Tensor<1,4> Tp4 = Construct1Tensor(p4); + Tensor<1,4> Tpa = Construct1Tensor(pa); + Tensor<1,4> Tpb = Construct1Tensor(pb); + Tensor<1,4> Tpq = Construct1Tensor(pq); + Tensor<1,4> Tpqbar = Construct1Tensor(pqbar); + Tensor<1,4> TAB = Construct1Tensor(pl+plbar); + Tensor<1,4> Tq1 = Construct1Tensor(q1); + Tensor<1,4> Tq3 = Construct1Tensor(q3); + Tensor<2,4> g=Metric(); + + // Define llx current. Note factor of 2 to account for sqrt(2) on each W vertex + Tensor<1,4> ABCur = TCurrent(pl, false, plbar,false)/2; + + //Blank 5 gamma Current + Tensor<5,4> J523 = T5Current(pq,false,pqbar,false); + + // 4 gamma currents (with 1 contraction already). + Tensor<4,4> J_q3q = J523.contract((Tq3+Tpq),2); + Tensor<4,4> J_2AB = J523.contract((Tpq+TAB),2); + + // Components of Crossed Vertex Contribution + Tensor<3,4> Xcro1 = J_q3q.contract((Tpqbar + TAB),3); + Tensor<3,4> Xcro2 = J_q3q.contract((Tq1-Tpqbar),3); + Tensor<3,4> Xcro3 = J_2AB.contract((Tq1-Tpqbar),3); + + // Term Denominators Taken Care of at this stage + Tensor<2,4> Xcro1Cont = Xcro1.contract(ABCur,3)/(tcro1*s3AB); + Tensor<2,4> Xcro2Cont = Xcro2.contract(ABCur,2)/(tcro1*tcro2); + Tensor<2,4> Xcro3Cont = Xcro3.contract(ABCur,1)/(s2AB*tcro2); + + //Initialise the Crossed Vertex Object + Tensor<2,4> Xcro(0.); + + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + Xcro.Set(mu,nu, -(-Xcro1Cont.at(nu,mu)+Xcro2Cont.at(nu,mu)+Xcro3Cont.at(nu,mu))); + } + } + + + return Xcro; + } + + // Helper Functions Calculate the Uncrossed Contribution + Tensor <2,4> MUncrossW(CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pb, CLHEP::HepLorentzVector p4, CLHEP::HepLorentzVector pq,CLHEP::HepLorentzVector pqbar,CLHEP::HepLorentzVector pl,CLHEP::HepLorentzVector plbar, std::vector partons, int nabove){ + + double s2AB=(pl+plbar+pq).m2(); + double s3AB=(pl+plbar+pqbar).m2(); + + CLHEP::HepLorentzVector q1, q3; + q1=pa; + for(int i=0; i Tp1 = Construct1Tensor(p1); + Tensor<1,4> Tp4 = Construct1Tensor(p4); + Tensor<1,4> Tpa = Construct1Tensor(pa); + Tensor<1,4> Tpb = Construct1Tensor(pb); + Tensor<1,4> Tpq = Construct1Tensor(pq); + Tensor<1,4> Tpqbar = Construct1Tensor(pqbar); + Tensor<1,4> TAB = Construct1Tensor(pl+plbar); + Tensor<1,4> Tq1 = Construct1Tensor(q1); + Tensor<1,4> Tq3 = Construct1Tensor(q3); + Tensor<2,4> g=Metric(); + + + // Define llx current. Note factor of 2 to account for sqrt(2) on each W vertex + Tensor<1,4> ABCur = TCurrent(pl, false, plbar, false)/2; + + //Blank 5 gamma Current + Tensor<5,4> J523 = T5Current(pq,false,pqbar,false); + + // 4 gamma currents (with 1 contraction already). + Tensor<4,4> J_2AB = J523.contract((Tpq+TAB),2); + Tensor<4,4> J_q1q = J523.contract((Tq1-Tpq),2); + + // 2 Contractions taken care of. + Tensor<3,4> Xunc1 = J_2AB.contract((Tq3+Tpqbar),3); + Tensor<3,4> Xunc2 = J_q1q.contract((Tq3+Tpqbar),3); + Tensor<3,4> Xunc3 = J_q1q.contract((Tpqbar+TAB),3); + + // Term Denominators Taken Care of at this stage + Tensor<2,4> Xunc1Cont = Xunc1.contract(ABCur,1)/(s2AB*tunc2); + Tensor<2,4> Xunc2Cont = Xunc2.contract(ABCur,2)/(tunc1*tunc2); + Tensor<2,4> Xunc3Cont = Xunc3.contract(ABCur,3)/(tunc1*s3AB); + + //Initialise the Uncrossed Vertex Object + Tensor<2,4> Xunc(0.); + + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + Xunc.Set(mu,nu,-(- Xunc1Cont.at(mu,nu)+Xunc2Cont.at(mu,nu) +Xunc3Cont.at(mu,nu))); + } + } + + return Xunc; + } + + + // Helper Functions Calculate the g->qqxW (Eikonal) Contributions + Tensor <2,4> MSymW(CLHEP::HepLorentzVector pa,CLHEP::HepLorentzVector p1,CLHEP::HepLorentzVector pb,CLHEP::HepLorentzVector p4, CLHEP::HepLorentzVector pq,CLHEP::HepLorentzVector pqbar,CLHEP::HepLorentzVector pl,CLHEP::HepLorentzVector plbar, std::vector partons, int nabove){ + + double sa2=(pa+pq).m2(); + double s12=(p1+pq).m2(); + double sa3=(pa+pqbar).m2(); + double s13=(p1+pqbar).m2(); + double saA=(pa+pl).m2(); + double s1A=(p1+pl).m2(); + double saB=(pa+plbar).m2(); + double s1B=(p1+plbar).m2(); + double sb2=(pb+pq).m2(); + double s42=(p4+pq).m2(); + double sb3=(pb+pqbar).m2(); + double s43=(p4+pqbar).m2(); + double sbA=(pb+pl).m2(); + double s4A=(p4+pl).m2(); + double sbB=(pb+plbar).m2(); + double s4B=(p4+plbar).m2(); + double s23AB=(pl+plbar+pq+pqbar).m2(); + + CLHEP::HepLorentzVector q1,q3; + q1=pa; + for(int i=0;i Tp1 = Construct1Tensor(p1); + Tensor<1,4> Tp4 = Construct1Tensor(p4); + Tensor<1,4> Tpa = Construct1Tensor(pa); + Tensor<1,4> Tpb = Construct1Tensor(pb); + Tensor<1,4> Tpq = Construct1Tensor(pq); + Tensor<1,4> Tpqbar = Construct1Tensor(pqbar); + Tensor<1,4> TAB = Construct1Tensor(pl+plbar); + Tensor<1,4> Tq1 = Construct1Tensor(q1); + Tensor<1,4> Tq3 = Construct1Tensor(q3); + Tensor<2,4> g=Metric(); + + // g->qqW Current (Factors of sqrt2 dealt with in this function.) + Tensor<1,4> JV = gtqqxW(pq,pqbar,pl,plbar); + + // 1a gluon emisson Contribution + Tensor<3,4> X1a = g.rightprod(Tp1*(t1/(s12+s13+s1A+s1B)) + Tpa*(t1/(sa2+sa3+saA+saB))); + Tensor<2,4> X1aCont = X1a.contract(JV,3); + + //4b gluon emission Contribution + Tensor<3,4> X4b = g.rightprod(Tp4*(t3/(s42+s43+s4A+s4B)) + Tpb*(t3/(sb2+sb3+sbA+sbB))); + Tensor<2,4> X4bCont = X4b.contract(JV,3); + + //Set up each term of 3G diagram. + Tensor<3,4> X3g1 = g.leftprod(Tq1+Tpq+Tpqbar+TAB); + Tensor<3,4> X3g2 = g.leftprod(Tq3-Tpq-Tpqbar-TAB); + Tensor<3,4> X3g3 = g.leftprod((Tq1+Tq3)); + + // Note the contraction of indices changes term by term + Tensor<2,4> X3g1Cont = X3g1.contract(JV,3); + Tensor<2,4> X3g2Cont = X3g2.contract(JV,2); + Tensor<2,4> X3g3Cont = X3g3.contract(JV,1); + + // XSym is an amalgamation of x1a, X4b and X3g. Makes sense from a colour factor point of view. + Tensor<2,4>Xsym(0.); + + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + Xsym.Set(mu,nu, (X3g1Cont.at(nu,mu) + X3g2Cont.at(mu,nu) - X3g3Cont.at(nu,mu)) + + (X1aCont.at(mu,nu) - X4bCont.at(mu,nu)) ); + } + } + return Xsym/s23AB; + } + +Tensor <2,4> MCross(CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector pq,CLHEP::HepLorentzVector pqbar, std::vector partons, bool hq, int nabove){ + + CLHEP::HepLorentzVector q1; + q1=pa; + for(int i=0;i Tq1 = Construct1Tensor(q1-pqbar); + + //Blank 3 gamma Current + Tensor<3,4> J323 = T3Current(pq,hq,pqbar,hq); + + // 2 gamma current (with 1 contraction already). + Tensor<2,4> XCroCont = J323.contract((Tq1),2)/(t2); + + //Initialise the Crossed Vertex + Tensor<2,4> Xcro(0.); + + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + Xcro.Set(mu,nu, (XCroCont.at(nu,mu))); + } + } + + return Xcro; +} + + + // Helper Functions Calculate the Uncrossed Contribution + Tensor <2,4> MUncross(CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector pq,CLHEP::HepLorentzVector pqbar, std::vector partons, bool hq, int nabove){ + + CLHEP::HepLorentzVector q1; + q1=pa; + for(int i=0;i Tq1 = Construct1Tensor(q1-pq); + + //Blank 3 gamma Current + Tensor<3,4> J323 = T3Current(pq,hq,pqbar,hq); + + // 2 gamma currents (with 1 contraction already). + Tensor<2,4> XUncCont = J323.contract((Tq1),2)/t2; + + //Initialise the Uncrossed Vertex + Tensor<2,4> Xunc(0.); + + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + Xunc.Set(mu,nu,-(XUncCont.at(mu,nu))); + } + } + + return Xunc; + } + + + // Helper Functions Calculate the Eikonal Contributions + Tensor <2,4> MSym(CLHEP::HepLorentzVector pa,CLHEP::HepLorentzVector p1,CLHEP::HepLorentzVector pb,CLHEP::HepLorentzVector p4, CLHEP::HepLorentzVector pq,CLHEP::HepLorentzVector pqbar, std::vector partons, bool hq, int nabove){ + + CLHEP::HepLorentzVector q1, q3; + q1=pa; + for(int i=0;i Tp1 = Construct1Tensor(p1); + Tensor<1,4> Tp4 = Construct1Tensor(p4); + Tensor<1,4> Tpa = Construct1Tensor(pa); + Tensor<1,4> Tpb = Construct1Tensor(pb); + Tensor<1,4> Tpq = Construct1Tensor(pq); + Tensor<1,4> Tpqbar = Construct1Tensor(pqbar); + Tensor<1,4> Tq1 = Construct1Tensor(q1); + Tensor<1,4> Tq3 = Construct1Tensor(q3); + Tensor<2,4> g=Metric(); + + Tensor<1,4> qqxCur = TCurrent(pq, hq, pqbar, hq); + + // // 1a gluon emisson Contribution + Tensor<3,4> X1a = g.rightprod(Tp1*(t1/(s12+s13))+Tpa*(t1/(sa2+sa3))); + Tensor<2,4> X1aCont = X1a.contract(qqxCur,3); + + // //4b gluon emission Contribution + Tensor<3,4> X4b = g.rightprod(Tp4*(t3/(s42+s43)) + Tpb*(t3/(sb2+sb3))); + Tensor<2,4> X4bCont = X4b.contract(qqxCur,3); + + // New Formulation Corresponding to New Analytics + Tensor<3,4> X3g1 = g.leftprod(Tq1+Tpq+Tpqbar); + Tensor<3,4> X3g2 = g.leftprod(Tq3-Tpq-Tpqbar); + Tensor<3,4> X3g3 = g.leftprod((Tq1+Tq3)); + + // Note the contraction of indices changes term by term + Tensor<2,4> X3g1Cont = X3g1.contract(qqxCur,3); + Tensor<2,4> X3g2Cont = X3g2.contract(qqxCur,2); + Tensor<2,4> X3g3Cont = X3g3.contract(qqxCur,1); + + Tensor<2,4>Xsym(0.); + + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + Xsym.Set(mu,nu, COM(0,1)*((X3g1Cont.at(nu,mu) + X3g2Cont.at(mu,nu) - X3g3Cont.at(nu,mu)) + + (X1aCont.at(mu,nu) - X4bCont.at(mu,nu)) )); + } + } + return Xsym/s23; + } + +Tensor <1,4> jW4bEmit(HLV pb, HLV p4, HLV pl, HLV plbar, bool aqlinepb){ + // Build the external quark line W Emmision + Tensor<1,4> ABCurr = TCurrent(pl, false, plbar, false)/2; + Tensor<1,4> Tp4W = Construct1Tensor((p4+pl+plbar));//p4+pw + Tensor<1,4> TpbW = Construct1Tensor((pb-pl-plbar));//pb-pw + + Tensor<3,4> J4bBlank; + if (aqlinepb){ + J4bBlank = T3Current(pb,false,p4,false); + } + else{ + J4bBlank = T3Current(p4,false,pb,false); + } + double t4AB = (p4+pl+plbar).m2(); + double tbAB = (pb-pl-plbar).m2(); + + Tensor<2,4> J4b1 = (J4bBlank.contract(Tp4W,2))/t4AB; + Tensor<2,4> J4b2 = (J4bBlank.contract(TpbW,2))/tbAB; + + Tensor<2,4> T4bmMom(0.); + + if (aqlinepb){ + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + T4bmMom.Set(mu,nu, (J4b1.at(nu,mu) + J4b2.at(mu,nu))*(COM(-1,0))); + } + } + } + else{ + for(int mu=0; mu<4;mu++){ + for(int nu=0;nu<4;nu++){ + T4bmMom.Set(nu,mu, (J4b1.at(nu,mu) + J4b2.at(mu,nu))); + } + } + } + Tensor<1,4> T4bm = T4bmMom.contract(ABCurr,1); + + return T4bm; +} + +} // Anonymous Namespace helper functions + + + +//Functions which can be called elsewhere (declarations in currents.hh). + +// FKL W+Jets +double jMWqQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + current mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out); + + jW(p1out,false,pe,false,pnu,false,p1in,false,mj1m); + j(p2out,true,p2in,true,mj2p); + j(p2out,false,p2in,false,mj2m); + + // mj1m.mj2p + COM Mmp=cdot(mj1m,mj2p); + + // mj1m.mj2m + COM Mmm=cdot(mj1m,mj2m); + + // sum of spinor strings ||^2 + double a2Mmp=abs2(Mmp); + double a2Mmm=abs2(Mmm); + + // // Leave division by colour and Helicity avg until Tree files + // Leave multi. of couplings to later + // Multiply by Cf^2 + return (4./3.)*(4./3.)*(a2Mmp+a2Mmm)/(q1.m2()*q2.m2()); + +} + +double jMWqQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + current mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out); + + jW(p1out,false,pe,false,pnu,false,p1in,false,mj1m); + jio(p2in,true,p2out,true,mj2p); + jio(p2in,false,p2out,false,mj2m); + + // mj1m.mj2p + COM Mmp=cdot(mj1m,mj2p); + + // mj1m.mj2m + COM Mmm=cdot(mj1m,mj2m); + + // sum of spinor strings ||^2 + double a2Mmp=abs2(Mmp); + double a2Mmm=abs2(Mmm); + + // // Leave division by colour and Helicity avg until Tree files + // Leave multi. of couplings to later + // Multiply by Cf^2 + return (4./3.)*(4./3.)*(a2Mmp+a2Mmm)/(q1.m2()*q2.m2()); + +} + +double jMWqbarQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + current mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out); + + jWbar(p1out,false,pe,false,pnu,false,p1in,false,mj1m); + j(p2out,true,p2in,true,mj2p); + j(p2out,false,p2in,false,mj2m); + + // mj1m.mj2p + COM Mmp=cdot(mj1m,mj2p); + + // mj1m.mj2m + COM Mmm=cdot(mj1m,mj2m); + + // sum of spinor strings ||^2 + double a2Mmp=abs2(Mmp); + double a2Mmm=abs2(Mmm); + + // // Leave division by colour and Helicity avg until Tree files + // Leave multi. of couplings to later + // Multiply by Cf^2 + return (4./3.)*(4./3.)*(a2Mmp+a2Mmm)/(q1.m2()*q2.m2()); + +} + +double jMWqbarQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + current mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out); + + jWbar(p1out,false,pe,false,pnu,false,p1in,false,mj1m); + jio(p2in,true,p2out,true,mj2p); + jio(p2in,false,p2out,false,mj2m); + + // mj1m.mj2p + COM Mmp=cdot(mj1m,mj2p); + + // mj1m.mj2m + COM Mmm=cdot(mj1m,mj2m); + + // sum of spinor strings ||^2 + double a2Mmp=abs2(Mmp); + double a2Mmm=abs2(Mmm); + + // // Leave division by colour and Helicity avg until Tree files + // Leave multi. of couplings to later + // Multiply by Cf^2 + return (4./3.)*(4./3.)*(a2Mmp+a2Mmm)/(q1.m2()*q2.m2()); + +} + +double jMWqg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qg->qenug scattering +// p1: quark +// p2: gluon +{ + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out); + current mj1m,mj2p,mj2m; + + jW(p1out,false,pe,false,pnu,false,p1in,false,mj1m); + + j(p2out,true,p2in,true,mj2p); + j(p2out,false,p2in,false,mj2m); + + // mj1m.mj2p + + COM Mmp=cdot(mj1m,mj2p); + + // mj1m.mj2m + COM Mmm=cdot(mj1m,mj2m); + + double ratio; // p2-/pb- in the notes + if (p2in.pz()>0.) // if the gluon is the positive + ratio=p2out.plus()/p2in.plus(); + else // the gluon is the negative + ratio=p2out.minus()/p2in.minus(); + + + double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; + + // sum of spinor strings ||^2 + double a2Mmp=abs2(Mmp); + double a2Mmm=abs2(Mmm); + double sst = nonflipcolourmult*(a2Mmp+a2Mmm); + // double sstsave=sst; + + // // Leave division by colour and Helicity avg until Tree files + // Leave multi. of couplings to later + // Multiply by Cf*Ca=4 + return 4.*sst/(q1.m2()*q2.m2()); + +} + +double jMWqbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qg->qenug scattering +// p1: quark +// p2: gluon +{ + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out); + current mj1m,mj2p,mj2m; + + jWbar(p1out,false,pe,false,pnu,false,p1in,false,mj1m); + + j(p2out,true,p2in,true,mj2p); + j(p2out,false,p2in,false,mj2m); + + // mj1m.mj2p + + COM Mmp=cdot(mj1m,mj2p); + + // mj1m.mj2m + COM Mmm=cdot(mj1m,mj2m); + + double ratio; // p2-/pb- in the notes + // if (p2in.plus()>0) // if the gluon is the positive + if (p2in.pz()>0.) // if the gluon is the positive + ratio=p2out.plus()/p2in.plus(); + else // the gluon is the negative + ratio=p2out.minus()/p2in.minus(); + + + double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; + + // sum of spinor strings ||^2 + double a2Mmp=abs2(Mmp); + double a2Mmm=abs2(Mmm); + double sst = nonflipcolourmult*(a2Mmp+a2Mmm); + // double sstsave=sst; + + // // Leave division by colour and Helicity avg until Tree files + // Leave multi. of couplings to later + // Multiply by Cf*Ca=4 + return 4.*sst/(q1.m2()*q2.m2()); + +} + +// W+Jets Unordered Contributions + +//qQ->qQWg_unob +double junobMWqQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); + CLHEP::HepLorentzVector q3=-(p2in-p2out); + + mj1m=jW(p1out,false,pe,false,pnu,false,p1in,false); + mj2p=j(p2out,true,p2in,true); + mj2m=j(p2out,false,p2in,false); + + + // Dot products of these which occur again and again + COM MWmp=mj1m.dot(mj2p); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgbm,jgbp,j2gm,j2gp; + j2gp=joo(p2out,true,pg,true); + j2gm=joo(p2out,false,pg,false); + jgbp=j(pg,true,p2in,true); + jgbm=j(pg,false,p2in,false); + + CCurrent qsum(q2+q3); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p1o(p1out),p1i(p1in); + CCurrent p2o(p2out); + CCurrent p2i(p2in); + + + Lmm=((-1.)*qsum*(MWmm) + (-2.*mj1m.dot(pg))*mj2m+2.*mj2m.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmm/2.))/q3.m2(); + Lmp=((-1.)*qsum*(MWmp) + (-2.*mj1m.dot(pg))*mj2p+2.*mj2p.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmp/2.))/q3.m2(); + + U1mm=(jgbm.dot(mj1m)*j2gm+2.*p2o*MWmm)/(p2out+pg).m2(); + U1mp=(jgbp.dot(mj1m)*j2gp+2.*p2o*MWmp)/(p2out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj1m)*jgbm+2.*p2i*MWmm)/(p2in-pg).m2(); + U2mp=((-1.)*j2gp.dot(mj1m)*jgbp+2.*p2i*MWmp)/(p2in-pg).m2(); + + + double cf=4./3.; + double amm,amp; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + amp=cf*(2.*vre(Lmp-U1mp,Lmp+U2mp))+2.*cf*cf/3.*vabs2(U1mp+U2mp); + + double ampsq=-(amm+amp); + + // Now add the t-channels + double th=q2.m2()*q1.m2(); + ampsq/=th; + ampsq/=16.; + + return ampsq; + + +} + +//qQbar->qQbarWg_unob +double junobMWqQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); + CLHEP::HepLorentzVector q3=-(p2in-p2out); + + mj1m=jW(p1out,false,pe,false,pnu,false,p1in,false); + mj2p=jio(p2in,true,p2out,true); + mj2m=jio(p2in,false,p2out,false); + + + // Dot products of these which occur again and again + COM MWmp=mj1m.dot(mj2p); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgbm,jgbp,j2gm,j2gp; + j2gp=joo(pg,true,p2out,true); + j2gm=joo(pg,false,p2out,false); + jgbp=jio(p2in,true,pg,true); + jgbm=jio(p2in,false,pg,false); + + CCurrent qsum(q2+q3); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p1o(p1out),p1i(p1in); + CCurrent p2o(p2out); + CCurrent p2i(p2in); + + + Lmm=((-1.)*qsum*(MWmm) + (-2.*mj1m.dot(pg))*mj2m+2.*mj2m.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmm/2.))/q3.m2(); + Lmp=((-1.)*qsum*(MWmp) + (-2.*mj1m.dot(pg))*mj2p+2.*mj2p.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmp/2.))/q3.m2(); + + U1mm=(jgbm.dot(mj1m)*j2gm+2.*p2o*MWmm)/(p2out+pg).m2(); + U1mp=(jgbp.dot(mj1m)*j2gp+2.*p2o*MWmp)/(p2out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj1m)*jgbm+2.*p2i*MWmm)/(p2in-pg).m2(); + U2mp=((-1.)*j2gp.dot(mj1m)*jgbp+2.*p2i*MWmp)/(p2in-pg).m2(); + + + double cf=4./3.; + double amm,amp; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + amp=cf*(2.*vre(Lmp-U1mp,Lmp+U2mp))+2.*cf*cf/3.*vabs2(U1mp+U2mp); + + double ampsq=-(amm+amp); + + // Now add the t-channels + double th=q2.m2()*q1.m2(); + ampsq/=th; + ampsq/=16.; + + return ampsq; + + +} + +//qbarQ->qbarQWg_unob +double junobMWqbarQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); + CLHEP::HepLorentzVector q3=-(p2in-p2out); + + mj1m=jWbar(p1out,false,pe,false,pnu,false,p1in,false); + mj2p=j(p2out,true,p2in,true); + mj2m=j(p2out,false,p2in,false); + + + // Dot products of these which occur again and again + COM MWmp=mj1m.dot(mj2p); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgbm,jgbp,j2gm,j2gp; + j2gp=joo(p2out,true,pg,true); + j2gm=joo(p2out,false,pg,false); + jgbp=j(pg,true,p2in,true); + jgbm=j(pg,false,p2in,false); + + CCurrent qsum(q2+q3); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p1o(p1out),p1i(p1in); + CCurrent p2o(p2out); + CCurrent p2i(p2in); + + + Lmm=((-1.)*qsum*(MWmm) + (-2.*mj1m.dot(pg))*mj2m+2.*mj2m.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmm/2.))/q3.m2(); + Lmp=((-1.)*qsum*(MWmp) + (-2.*mj1m.dot(pg))*mj2p+2.*mj2p.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmp/2.))/q3.m2(); + + U1mm=(jgbm.dot(mj1m)*j2gm+2.*p2o*MWmm)/(p2out+pg).m2(); + U1mp=(jgbp.dot(mj1m)*j2gp+2.*p2o*MWmp)/(p2out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj1m)*jgbm+2.*p2i*MWmm)/(p2in-pg).m2(); + U2mp=((-1.)*j2gp.dot(mj1m)*jgbp+2.*p2i*MWmp)/(p2in-pg).m2(); + + + double cf=4./3.; + double amm,amp; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + amp=cf*(2.*vre(Lmp-U1mp,Lmp+U2mp))+2.*cf*cf/3.*vabs2(U1mp+U2mp); + + double ampsq=-(amm+amp); + + // Now add the t-channels + double th=q2.m2()*q1.m2(); + ampsq/=th; + ampsq/=16.; + + return ampsq; + + +} + +//qbarQbar->qbarQbarWg_unob +double junobMWqbarQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pg) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj1m,mj2p,mj2m; + CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); + CLHEP::HepLorentzVector q3=-(p2in-p2out); + + mj1m=jWbar(p1out,false,pe,false,pnu,false,p1in,false); + mj2p=jio(p2in,true,p2out,true); + mj2m=jio(p2in,false,p2out,false); + + + // Dot products of these which occur again and again + COM MWmp=mj1m.dot(mj2p); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgbm,jgbp,j2gm,j2gp; + j2gp=joo(pg,true,p2out,true); + j2gm=joo(pg,false,p2out,false); + jgbp=jio(p2in,true,pg,true); + jgbm=jio(p2in,false,pg,false); + + CCurrent qsum(q2+q3); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p1o(p1out),p1i(p1in); + CCurrent p2o(p2out); + CCurrent p2i(p2in); + + + Lmm=((-1.)*qsum*(MWmm) + (-2.*mj1m.dot(pg))*mj2m+2.*mj2m.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmm/2.))/q3.m2(); + Lmp=((-1.)*qsum*(MWmp) + (-2.*mj1m.dot(pg))*mj2p+2.*mj2p.dot(pg)*mj1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))*(q2.m2()*MWmp/2.))/q3.m2(); + + U1mm=(jgbm.dot(mj1m)*j2gm+2.*p2o*MWmm)/(p2out+pg).m2(); + U1mp=(jgbp.dot(mj1m)*j2gp+2.*p2o*MWmp)/(p2out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj1m)*jgbm+2.*p2i*MWmm)/(p2in-pg).m2(); + U2mp=((-1.)*j2gp.dot(mj1m)*jgbp+2.*p2i*MWmp)/(p2in-pg).m2(); + + + double cf=4./3.; + double amm,amp; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + amp=cf*(2.*vre(Lmp-U1mp,Lmp+U2mp))+2.*cf*cf/3.*vabs2(U1mp+U2mp); + + double ampsq=-(amm+amp); + + // Now add the t-channels + double th=q2.m2()*q1.m2(); + ampsq/=th; + ampsq/=16.; + + return ampsq; + + +} + +//////////////////////////////////////////////////////////////////// +//qQ->qQWg_unof +double junofMWgqQ (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj2m,mj1p,mj1m; + CLHEP::HepLorentzVector q1=p1in-p1out; + CLHEP::HepLorentzVector qg=p1in-p1out-pg; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pe-pnu); + + mj2m=jW(p2out,false,pe,false,pnu,false,p2in,false); + mj1p=j(p1out,true,p1in,true); + mj1m=j(p1out,false,p1in,false); + + + // Dot products of these which occur again and again + COM MWpm=mj1p.dot(mj2m); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgam,jgap,j2gm,j2gp; + j2gp=joo(p1out,true,pg,true); + j2gm=joo(p1out,false,pg,false); + jgap=j(pg,true,p1in,true); + jgam=j(pg,false,p1in,false); + + CCurrent qsum(q1+qg); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p2o(p2out),p2i(p2in); + CCurrent p1o(p1out); + CCurrent p1i(p1in); + + Lmm=(qsum*(MWmm) + (-2.*mj2m.dot(pg))*mj1m+2.*mj1m.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWmm/2.))/q1.m2(); + + Lpm=(qsum*(MWpm) + (-2.*mj2m.dot(pg))*mj1p+2.*mj1p.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWpm/2.))/q1.m2(); + + + U1mm=(jgam.dot(mj2m)*j2gm+2.*p1o*MWmm)/(p1out+pg).m2(); + + U1pm=(jgap.dot(mj2m)*j2gp+2.*p1o*MWpm)/(p1out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj2m)*jgam+2.*p1i*MWmm)/(p1in-pg).m2(); + + U2pm=((-1.)*j2gp.dot(mj2m)*jgap+2.*p1i*MWpm)/(p1in-pg).m2(); + + + double cf=4./3.; + double amm,apm; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + + apm=cf*(2.*vre(Lpm-U1pm,Lpm+U2pm))+2.*cf*cf/3.*vabs2(U1pm+U2pm); + + + + double ampsq=-(apm+amm); + + // Now add the t-channels + double th=q2.m2()*qg.m2(); + ampsq/=th; + ampsq/=16.; + + return ampsq; + + +} + +//qQbar->qQbarWg_unof +double junofMWgqQbar (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj2m,mj1p,mj1m; + CLHEP::HepLorentzVector q1=p1in-p1out; + CLHEP::HepLorentzVector qg=p1in-p1out-pg; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pe-pnu); + + mj2m=jWbar(p2out,false,pe,false,pnu,false,p2in,false); + mj1p=j(p1out,true,p1in,true); + mj1m=j(p1out,false,p1in,false); + + + // Dot products of these which occur again and again + COM MWpm=mj1p.dot(mj2m); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgam,jgap,j2gm,j2gp; + j2gp=joo(p1out,true,pg,true); + j2gm=joo(p1out,false,pg,false); + jgap=j(pg,true,p1in,true); + jgam=j(pg,false,p1in,false); + + CCurrent qsum(q1+qg); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p2o(p2out),p2i(p2in); + CCurrent p1o(p1out); + CCurrent p1i(p1in); + + Lmm=(qsum*(MWmm) + (-2.*mj2m.dot(pg))*mj1m+2.*mj1m.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWmm/2.))/q1.m2(); + + Lpm=(qsum*(MWpm) + (-2.*mj2m.dot(pg))*mj1p+2.*mj1p.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWpm/2.))/q1.m2(); + + + U1mm=(jgam.dot(mj2m)*j2gm+2.*p1o*MWmm)/(p1out+pg).m2(); + + U1pm=(jgap.dot(mj2m)*j2gp+2.*p1o*MWpm)/(p1out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj2m)*jgam+2.*p1i*MWmm)/(p1in-pg).m2(); + + U2pm=((-1.)*j2gp.dot(mj2m)*jgap+2.*p1i*MWpm)/(p1in-pg).m2(); + + + double cf=4./3.; + double amm,apm; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + + apm=cf*(2.*vre(Lpm-U1pm,Lpm+U2pm))+2.*cf*cf/3.*vabs2(U1pm+U2pm); + + + + double ampsq=-(apm+amm); + + // Now add the t-channels + double th=q2.m2()*qg.m2(); + ampsq/=th; + ampsq/=16.; + + return ampsq; +} + +//qbarQ->qbarQWg_unof +double junofMWgqbarQ (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj2m,mj1p,mj1m; + CLHEP::HepLorentzVector q1=p1in-p1out; + CLHEP::HepLorentzVector qg=p1in-p1out-pg; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pe-pnu); + + mj2m=jW(p2out,false,pe,false,pnu,false,p2in,false); + mj1p=jio(p1in,true,p1out,true); + mj1m=jio(p1in,false,p1out,false); + + + // Dot products of these which occur again and again + COM MWpm=mj1p.dot(mj2m); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgam,jgap,j2gm,j2gp; + j2gp=joo(pg,true,p1out,true); + j2gm=joo(pg,false,p1out,false); + jgap=jio(p1in,true,pg,true); + jgam=jio(p1in,false,pg,false); + + CCurrent qsum(q1+qg); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p2o(p2out),p2i(p2in); + CCurrent p1o(p1out); + CCurrent p1i(p1in); + + Lmm=(qsum*(MWmm) + (-2.*mj2m.dot(pg))*mj1m+2.*mj1m.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWmm/2.))/q1.m2(); + + Lpm=(qsum*(MWpm) + (-2.*mj2m.dot(pg))*mj1p+2.*mj1p.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWpm/2.))/q1.m2(); + + + U1mm=(jgam.dot(mj2m)*j2gm+2.*p1o*MWmm)/(p1out+pg).m2(); + + U1pm=(jgap.dot(mj2m)*j2gp+2.*p1o*MWpm)/(p1out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj2m)*jgam+2.*p1i*MWmm)/(p1in-pg).m2(); + + U2pm=((-1.)*j2gp.dot(mj2m)*jgap+2.*p1i*MWpm)/(p1in-pg).m2(); + + + double cf=4./3.; + double amm,apm; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + + apm=cf*(2.*vre(Lpm-U1pm,Lpm+U2pm))+2.*cf*cf/3.*vabs2(U1pm+U2pm); + + + + double ampsq=-(apm+amm); + + // Now add the t-channels + double th=q2.m2()*qg.m2(); + ampsq/=th; + ampsq/=16.; + + return ampsq; + + +} + +//qbarQbar->qbarQbarWg_unof +double junofMWgqbarQbar (CLHEP::HepLorentzVector pg,CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu, CLHEP::HepLorentzVector p2in) +// Calculates the square of the current contractions for qQ->qenuQ scattering +// p1: quark (with W emittance) +// p2: Quark +{ + CCurrent mj2m,mj1p,mj1m; + CLHEP::HepLorentzVector q1=p1in-p1out; + CLHEP::HepLorentzVector qg=p1in-p1out-pg; + CLHEP::HepLorentzVector q2=-(p2in-p2out-pe-pnu); + + mj2m=jWbar(p2out,false,pe,false,pnu,false,p2in,false); + mj1p=jio(p1in,true,p1out,true); + mj1m=jio(p1in,false,p1out,false); + + + // Dot products of these which occur again and again + COM MWpm=mj1p.dot(mj2m); // And now for the Higgs ones + COM MWmm=mj1m.dot(mj2m); + + CCurrent jgam,jgap,j2gm,j2gp; + j2gp=joo(pg,true,p1out,true); + j2gm=joo(pg,false,p1out,false); + jgap=jio(p1in,true,pg,true); + jgam=jio(p1in,false,pg,false); + + CCurrent qsum(q1+qg); + + CCurrent Lmp,Lmm,Lpp,Lpm,U1mp,U1mm,U1pp,U1pm,U2mp,U2mm,U2pp,U2pm,p2o(p2out),p2i(p2in); + CCurrent p1o(p1out); + CCurrent p1i(p1in); + + Lmm=(qsum*(MWmm) + (-2.*mj2m.dot(pg))*mj1m+2.*mj1m.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWmm/2.))/q1.m2(); + + Lpm=(qsum*(MWpm) + (-2.*mj2m.dot(pg))*mj1p+2.*mj1p.dot(pg)*mj2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))*(qg.m2()*MWpm/2.))/q1.m2(); + + + U1mm=(jgam.dot(mj2m)*j2gm+2.*p1o*MWmm)/(p1out+pg).m2(); + + U1pm=(jgap.dot(mj2m)*j2gp+2.*p1o*MWpm)/(p1out+pg).m2(); + + U2mm=((-1.)*j2gm.dot(mj2m)*jgam+2.*p1i*MWmm)/(p1in-pg).m2(); + + U2pm=((-1.)*j2gp.dot(mj2m)*jgap+2.*p1i*MWpm)/(p1in-pg).m2(); + + + double cf=4./3.; + double amm,apm; + + amm=cf*(2.*vre(Lmm-U1mm,Lmm+U2mm))+2.*cf*cf/3.*vabs2(U1mm+U2mm); + + apm=cf*(2.*vre(Lpm-U1pm,Lpm+U2pm))+2.*cf*cf/3.*vabs2(U1pm+U2pm); + + + + double ampsq=-(apm+amm); + + + // Now add the t-channels + double th=q2.m2()*qg.m2(); + ampsq/=th; + ampsq/=16.; + return ampsq; + + +} + + + +//Naming scheme jM2-Wuno-g-({q/qbar}{Q/Qbar/g}) +double jM2WunogqQ(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,true); + ME2mpm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,false); + ME2mmp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,true); + ME2mmm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + return ME2; + +} + +//same as function above but actually obtaining the antiquark line by crossing symmetry, where p1out and p1in are expected to be negative. +//should give same result as jM2WunogqbarQ below (verified) +double jM2WunogqQ_crossqQ(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,true); + ME2mpm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,false); + ME2mmp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,true); + ME2mmm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + return ME2; + +} + + +double jM2WunogqQbar(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,true); + ME2mpm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,false); + ME2mmp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,true); + ME2mmm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + return ME2; + +} + +double jM2Wunogqg(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,true); + ME2mpm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,true,false); + ME2mmp = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,true); + ME2mmm = jM2Wuno(pg, p1out,plbar,pl,p1in,false,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + double ca = 3.; + double cf = 4./3.; + + double ratio; // p2-/pb- in the notes + if (p2in.pz()>0.) // if the gluon is the positive + ratio=p2out.plus()/p2in.plus(); + else // the gluon is the negative + ratio=p2out.minus()/p2in.minus(); + + double cam = ( (ca - 1/ca)*(ratio + 1./ratio)/2. + 1/ca)/cf; + ME2*=cam; + + return ME2; + +} + +double jM2WunogqbarQ(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,true,true); + ME2mpm = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,true,false); + ME2mmp = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,false,true); + ME2mmm = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + return ME2; + +} + +double jM2WunogqbarQbar(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,true,true); + ME2mpm = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,true,false); + ME2mmp = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,false,true); + ME2mmm = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + return ME2; + +} + +double jM2Wunogqbarg(CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,true,true); + ME2mpm = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,true,false); + ME2mmp = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,false,true); + ME2mmm = jM2Wuno(pg, p1out,plbar,pl,p1in,true,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + double ca = 3.; + double cf = 4./3.; + + double ratio; // p2-/pb- in the notes + if (p2in.pz()>0.) // if the gluon is the positive + ratio=p2out.plus()/p2in.plus(); + else // the gluon is the negative + ratio=p2out.minus()/p2in.minus(); + + double cam = ( (ca - 1/ca)*(ratio + 1./ratio)/2. + 1/ca)/cf; + ME2*=cam; + + return ME2; + +} + + +// W+Jets qqxExtremal +// W+Jets qqxExtremal Currents - wqq emission +double jM2WgQtoqbarqQ(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqbarout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,true,true); + ME2mpm = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,true,false); + ME2mmp = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,false,true); + ME2mmm = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + //Correct colour averaging + ME2*=(3.0/8.0); + + return ME2; + +} + +double jM2WgQtoqqbarQ(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqbarout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in){ + + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,true,true); + ME2mpm = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,true,false); + ME2mmp = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,false,true); + ME2mmm = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + //Correct colour averaging + ME2*=(3.0/8.0); + + return ME2; + +} + + +double jM2Wggtoqbarqg(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqbarout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) +{ + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,true,true); + ME2mpm = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,true,false); + ME2mmp = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,false,true); + ME2mmm = jM2Wuno(-pgin, pqout,plbar,pl,-pqbarout,false,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + double ca = 3.; + double cf = 4./3.; + + double ratio; // p2-/pb- in the notes + if (p2in.pz()>0.) // if the gluon is the positive + ratio=p2out.plus()/p2in.plus(); + else // the gluon is the negative + ratio=p2out.minus()/p2in.minus(); + + double cam = ( (ca - 1/ca)*(ratio + 1./ratio)/2. + 1/ca)/cf; + ME2*=cam; + + //Correct colour averaging + ME2*=(3.0/8.0); + + return ME2; +} + +double jM2Wggtoqqbarg(CLHEP::HepLorentzVector pgin, CLHEP::HepLorentzVector pqbarout,CLHEP::HepLorentzVector plbar,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector pqout, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in){ + + //COM temp; + double ME2mpp=0.; + double ME2mpm=0.; + double ME2mmp=0.; + double ME2mmm=0.; + double ME2; + + ME2mpp = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,true,true); + ME2mpm = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,true,false); + ME2mmp = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,false,true); + ME2mmm = jM2Wuno(-pgin, pqbarout,plbar,pl,-pqout,true,p2out,p2in,false,false); + + //Helicity sum + ME2 = ME2mpp + ME2mpm + ME2mmp + ME2mmm; + + double ca = 3.; + double cf = 4./3.; + + double ratio; // p2-/pb- in the notes + if (p2in.pz()>0.) // if the gluon is the positive + ratio=p2out.plus()/p2in.plus(); + else // the gluon is the negative + ratio=p2out.minus()/p2in.minus(); + + double cam = ( (ca - 1/ca)*(ratio + 1./ratio)/2. + 1/ca)/cf; + ME2*=cam; + + //Correct colour averaging + ME2*=(3.0/8.0); + + return ME2; + +} + + + +// W+Jets qqxCentral +double jM2WqqtoqQQq(CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector pb,CLHEP::HepLorentzVector pl, CLHEP::HepLorentzVector plbar, std::vector partons, bool aqlinepa, bool aqlinepb, bool qqxmarker, int nabove) +{ + + static bool is_sigma_index_set(false); + if(!is_sigma_index_set){ + if(init_sigma_index()) + is_sigma_index_set = true; + else + return 0.;} + + HLV pq, pqbar, p1, p4; + if (qqxmarker){ + pqbar = partons[nabove+1]; + pq = partons[nabove+2];} + else{ + pq = partons[nabove+1]; + pqbar = partons[nabove+2];} + + p1 = partons.front(); + p4 = partons.back(); + + Tensor<1,4> T1am, T4bm, T1ap, T4bp; + if(!(aqlinepa)){ + T1ap = TCurrent(p1, true, pa, true); + T1am = TCurrent(p1, false, pa, false);} + else if(aqlinepa){ + T1ap = TCurrent(pa, true, p1, true); + T1am = TCurrent(pa, false, p1, false);} + if(!(aqlinepb)){ + T4bp = TCurrent(p4, true, pb, true); + T4bm = TCurrent(p4, false, pb, false);} + else if(aqlinepb){ + T4bp = TCurrent(pb, true, p4, true); + T4bm = TCurrent(pb, false, p4, false);} + + // Calculate the 3 separate contributions to the effective vertex + Tensor<2,4> Xunc = MUncrossW(pa, p1, pb, p4, pq, pqbar, pl, plbar, partons, nabove); + Tensor<2,4> Xcro = MCrossW( pa, p1, pb, p4, pq, pqbar, pl, plbar, partons, nabove); + Tensor<2,4> Xsym = MSymW( pa, p1, pb, p4, pq, pqbar, pl, plbar, partons, nabove); + + // 4 Different Helicity Choices (Differs from Pure Jet Case, where there is also the choice in qqbar helicity. + // (- - hel choice) + COM M_mmUnc = (((Xunc).contract(T1am,1)).contract(T4bm,1)).at(0); + COM M_mmCro = (((Xcro).contract(T1am,1)).contract(T4bm,1)).at(0); + COM M_mmSym = (((Xsym).contract(T1am,1)).contract(T4bm,1)).at(0); + // (- + hel choice) + COM M_mpUnc = (((Xunc).contract(T1am,1)).contract(T4bp,1)).at(0); + COM M_mpCro = (((Xcro).contract(T1am,1)).contract(T4bp,1)).at(0); + COM M_mpSym = (((Xsym).contract(T1am,1)).contract(T4bp,1)).at(0); + // (+ - hel choice) + COM M_pmUnc = (((Xunc).contract(T1ap,1)).contract(T4bm,1)).at(0); + COM M_pmCro = (((Xcro).contract(T1ap,1)).contract(T4bm,1)).at(0); + COM M_pmSym = (((Xsym).contract(T1ap,1)).contract(T4bm,1)).at(0); + // (+ + hel choice) + COM M_ppUnc = (((Xunc).contract(T1ap,1)).contract(T4bp,1)).at(0); + COM M_ppCro = (((Xcro).contract(T1ap,1)).contract(T4bp,1)).at(0); + COM M_ppSym = (((Xsym).contract(T1ap,1)).contract(T4bp,1)).at(0); + + //Colour factors: + COM cmsms,cmumu,cmcmc,cmsmu,cmsmc,cmumc; + cmsms=3.; + cmumu=4./3.; + cmcmc=4./3.; + cmsmu =3./2.*COM(0.,1.); + cmsmc = -3./2.*COM(0.,1.); + cmumc = -1./6.; + + // Work Out Interference in each case of helicity: + double amp_mm = real(cmsms*pow(abs(M_mmSym),2) + +cmumu*pow(abs(M_mmUnc),2) + +cmcmc*pow(abs(M_mmCro),2) + +2.*real(cmsmu*M_mmSym*conj(M_mmUnc)) + +2.*real(cmsmc*M_mmSym*conj(M_mmCro)) + +2.*real(cmumc*M_mmUnc*conj(M_mmCro))); + + double amp_mp = real(cmsms*pow(abs(M_mpSym),2) + +cmumu*pow(abs(M_mpUnc),2) + +cmcmc*pow(abs(M_mpCro),2) + +2.*real(cmsmu*M_mpSym*conj(M_mpUnc)) + +2.*real(cmsmc*M_mpSym*conj(M_mpCro)) + +2.*real(cmumc*M_mpUnc*conj(M_mpCro))); + + double amp_pm = real(cmsms*pow(abs(M_pmSym),2) + +cmumu*pow(abs(M_pmUnc),2) + +cmcmc*pow(abs(M_pmCro),2) + +2.*real(cmsmu*M_pmSym*conj(M_pmUnc)) + +2.*real(cmsmc*M_pmSym*conj(M_pmCro)) + +2.*real(cmumc*M_pmUnc*conj(M_pmCro))); + + double amp_pp = real(cmsms*pow(abs(M_ppSym),2) + +cmumu*pow(abs(M_ppUnc),2) + +cmcmc*pow(abs(M_ppCro),2) + +2.*real(cmsmu*M_ppSym*conj(M_ppUnc)) + +2.*real(cmsmc*M_ppSym*conj(M_ppCro)) + +2.*real(cmumc*M_ppUnc*conj(M_ppCro))); + + double amp=((amp_mm+amp_mp+amp_pm+amp_pp)/(9.*4.)); + + + + CLHEP::HepLorentzVector q1,q3; + q1=pa; + for(int i=0;i partons, bool aqlinepa, bool aqlinepb, bool qqxmarker, int nabove, int nbelow, bool forwards){ + + static bool is_sigma_index_set(false); + if(!is_sigma_index_set){ + if(init_sigma_index()) + is_sigma_index_set = true; + else + return 0.; + } + + if (!forwards){ //If Emission from Leg a instead, flip process. + HLV dummymom = pa; + bool dummybool= aqlinepa; + int dummyint = nabove; + pa = pb; + pb = dummymom; + std::reverse(partons.begin(),partons.end()); + qqxmarker = !(qqxmarker); + aqlinepa = aqlinepb; + aqlinepb = dummybool; + nabove = nbelow; + nbelow = dummyint; + } + + HLV pq, pqbar, p1,p4; + if (qqxmarker){ + pqbar = partons[nabove+1]; + pq = partons[nabove+2];} + else{ + pq = partons[nabove+1]; + pqbar = partons[nabove+2];} + + p1 = partons.front(); + p4 = partons.back(); + + Tensor<1,4> T1am(0.), T1ap(0.); + if(!(aqlinepa)){ + T1ap = TCurrent(p1, true, pa, true); + T1am = TCurrent(p1, false, pa, false);} + else if(aqlinepa){ + T1ap = TCurrent(pa, true, p1, true); + T1am = TCurrent(pa, false, p1, false);} + + Tensor <1,4> T4bm = jW4bEmit(pb, p4, pl, plbar, aqlinepb); + + // Calculate the 3 separate contributions to the effective vertex + Tensor<2,4> Xunc_m = MUncross(pa, pq, pqbar,partons, false, nabove); + Tensor<2,4> Xcro_m = MCross( pa, pq, pqbar,partons, false, nabove); + Tensor<2,4> Xsym_m = MSym( pa, p1, pb, p4, pq, pqbar, partons, false, nabove); + + Tensor<2,4> Xunc_p = MUncross(pa, pq, pqbar,partons, true, nabove); + Tensor<2,4> Xcro_p = MCross( pa, pq, pqbar,partons, true, nabove); + Tensor<2,4> Xsym_p = MSym( pa, p1, pb, p4, pq, pqbar, partons, true, nabove); + + + // (- - hel choice) + COM M_mmUnc = (((Xunc_m).contract(T1am,1)).contract(T4bm,1)).at(0); + COM M_mmCro = (((Xcro_m).contract(T1am,1)).contract(T4bm,1)).at(0); + COM M_mmSym = (((Xsym_m).contract(T1am,1)).contract(T4bm,1)).at(0); + // (- + hel choice) + COM M_mpUnc = (((Xunc_p).contract(T1am,1)).contract(T4bm,1)).at(0); + COM M_mpCro = (((Xcro_p).contract(T1am,1)).contract(T4bm,1)).at(0); + COM M_mpSym = (((Xsym_p).contract(T1am,1)).contract(T4bm,1)).at(0); + // (+ - hel choice) + COM M_pmUnc = (((Xunc_m).contract(T1ap,1)).contract(T4bm,1)).at(0); + COM M_pmCro = (((Xcro_m).contract(T1ap,1)).contract(T4bm,1)).at(0); + COM M_pmSym = (((Xsym_m).contract(T1ap,1)).contract(T4bm,1)).at(0); + // (+ + hel choice) + COM M_ppUnc = (((Xunc_p).contract(T1ap,1)).contract(T4bm,1)).at(0); + COM M_ppCro = (((Xcro_p).contract(T1ap,1)).contract(T4bm,1)).at(0); + COM M_ppSym = (((Xsym_p).contract(T1ap,1)).contract(T4bm,1)).at(0); + + //Colour factors: + COM cmsms,cmumu,cmcmc,cmsmu,cmsmc,cmumc; + cmsms=3.; + cmumu=4./3.; + cmcmc=4./3.; + cmsmu =3./2.*COM(0.,1.); + cmsmc = -3./2.*COM(0.,1.); + cmumc = -1./6.; + + // Work Out Interference in each case of helicity: + double amp_mm = real(cmsms*pow(abs(M_mmSym),2) + +cmumu*pow(abs(M_mmUnc),2) + +cmcmc*pow(abs(M_mmCro),2) + +2.*real(cmsmu*M_mmSym*conj(M_mmUnc)) + +2.*real(cmsmc*M_mmSym*conj(M_mmCro)) + +2.*real(cmumc*M_mmUnc*conj(M_mmCro))); + + double amp_mp = real(cmsms*pow(abs(M_mpSym),2) + +cmumu*pow(abs(M_mpUnc),2) + +cmcmc*pow(abs(M_mpCro),2) + +2.*real(cmsmu*M_mpSym*conj(M_mpUnc)) + +2.*real(cmsmc*M_mpSym*conj(M_mpCro)) + +2.*real(cmumc*M_mpUnc*conj(M_mpCro))); + + double amp_pm = real(cmsms*pow(abs(M_pmSym),2) + +cmumu*pow(abs(M_pmUnc),2) + +cmcmc*pow(abs(M_pmCro),2) + +2.*real(cmsmu*M_pmSym*conj(M_pmUnc)) + +2.*real(cmsmc*M_pmSym*conj(M_pmCro)) + +2.*real(cmumc*M_pmUnc*conj(M_pmCro))); + + double amp_pp = real(cmsms*pow(abs(M_ppSym),2) + +cmumu*pow(abs(M_ppUnc),2) + +cmcmc*pow(abs(M_ppCro),2) + +2.*real(cmsmu*M_ppSym*conj(M_ppUnc)) + +2.*real(cmsmc*M_ppSym*conj(M_ppCro)) + +2.*real(cmumc*M_ppUnc*conj(M_ppCro))); + + double amp=((amp_mm+amp_mp+amp_pm+amp_pp)/(9.*4.)); + + CLHEP::HepLorentzVector q1,q3; + q1=pa; + for(int i=0;i const COM looprwfactor = (COM(0.,1.)*M_PI*M_PI)/pow((2.*M_PI),4); //const double HVE = 246.21845810181637; #ifdef RHEJ_BUILD_WITH_QCDLOOP #include "qcdloop/qcdloop.h" #endif #include namespace { // Loop integrals #ifdef RHEJ_BUILD_WITH_QCDLOOP COM B0DD(CLHEP::HepLorentzVector q, double mq) { static std::vector> result(3); static auto ql_B0 = [](){ ql::Bubble,double,double> ql_B0; ql_B0.setCacheSize(100); return ql_B0; }(); static std::vector masses(2); static std::vector momenta(1); for(auto & m: masses) m = mq*mq; momenta.front() = q.m2(); ql_B0.integral(result, 1, masses, momenta); return result[0]; } COM C0DD(CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mq) { static std::vector> result(3); static auto ql_C0 = [](){ ql::Triangle,double,double> ql_C0; ql_C0.setCacheSize(100); return ql_C0; }(); static std::vector masses(3); static std::vector momenta(3); for(auto & m: masses) m = mq*mq; momenta[0] = q1.m2(); momenta[1] = q2.m2(); momenta[2] = (q1+q2).m2(); ql_C0.integral(result, 1, masses, momenta); return result[0]; } COM D0DD(CLHEP::HepLorentzVector q1,CLHEP::HepLorentzVector q2, CLHEP::HepLorentzVector q3, double mq) { static std::vector> result(3); static auto ql_D0 = [](){ ql::Box,double,double> ql_D0; ql_D0.setCacheSize(100); return ql_D0; }(); static std::vector masses(4); static std::vector momenta(6); for(auto & m: masses) m = mq*mq; momenta[0] = q1.m2(); momenta[1] = q2.m2(); momenta[2] = q3.m2(); momenta[3] = (q1+q2+q3).m2(); momenta[4] = (q1+q2).m2(); momenta[5] = (q2+q3).m2(); ql_D0.integral(result, 1, masses, momenta); return result[0]; } #else // no QCDloop COM B0an(double q2, double mt) // This is the bubble integral as given in Eq. (A.4) of VDD { COM ans(COM(0.,0.)); double mt2; //std::cerr<<"mt in B0an = "<0&&q2<4*mt2) { ans=-1./8/M_PI/M_PI*sqrt((4*mt2-q2)/q2)*atan(sqrt(q2/(4*mt2-q2))); } else if (q2<=0||q2>=4*mt2) { ans=-1./16/M_PI/M_PI*sqrt((q2-4*mt2)/q2)*log(COM(1.+sqrt(q2/(q2-4*mt2)))/(1.-sqrt(q2/(q2-4*mt2)))); } else { std::cout << "Error in B0an!"<pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0]=sqpop*sqpip; cur[1]=sqpom*sqpip*poperp/abs(poperp); cur[2]=-COM(0,1)*cur[1]; cur[3]=cur[0]; } else { // if backward double sqpim=sqrt(pin.minus()); cur[0]=-sqpom*sqpim*poperp/abs(poperp); cur[1]=-sqpim*sqpop; cur[2]=COM(0,1)*cur[1]; cur[3]=-cur[0]; } } else { // positive helicity if (pin.plus()>pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0]=sqpop*sqpip; cur[1]=sqpom*sqpip*conj(poperp)/abs(poperp); cur[2]=COM(0,1)*cur[1]; cur[3]=cur[0]; } else { // if backward double sqpim=sqrt(pin.minus()); cur[0]=-sqpom*sqpim*conj(poperp)/abs(poperp); cur[1]=-sqpim*sqpop; cur[2]=-COM(0,1)*cur[1]; cur[3]=-cur[0]; } } } CCurrent j (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pin, bool helin) { COM cur[4]; cur[0]=0.; cur[1]=0.; cur[2]=0.; cur[3]=0.; double sqpop=sqrt(pout.plus()); double sqpom=sqrt(pout.minus()); COM poperp=pout.x()+COM(0,1)*pout.y(); if (helout!=helin) { std::cerr<< "void j : Non-matching helicities\n"; } else if (helout==false) { // negative helicity if (pin.plus()>pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0]=sqpop*sqpip; cur[1]=sqpom*sqpip*poperp/abs(poperp); cur[2]=-COM(0,1)*cur[1]; cur[3]=cur[0]; } else { // if backward double sqpim=sqrt(pin.minus()); cur[0]=-sqpom*sqpim*poperp/abs(poperp); cur[1]=-sqpim*sqpop; cur[2]=COM(0,1)*cur[1]; cur[3]=-cur[0]; } } else { // positive helicity if (pin.plus()>pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0]=sqpop*sqpip; cur[1]=sqpom*sqpip*conj(poperp)/abs(poperp); cur[2]=COM(0,1)*cur[1]; cur[3]=cur[0]; } else { // if backward double sqpim=sqrt(pin.minus()); cur[0]=-sqpom*sqpim*conj(poperp)/abs(poperp); cur[1]=-sqpim*sqpop; cur[2]=-COM(0,1)*cur[1]; cur[3]=-cur[0]; } } CCurrent temp(cur[0],cur[1],cur[2],cur[3]); return temp; } CCurrent jio (CLHEP::HepLorentzVector pin, bool helin, CLHEP::HepLorentzVector pout, bool helout) { COM cur[4]; cur[0]=0.; cur[1]=0.; cur[2]=0.; cur[3]=0.; double sqpop=sqrt(pout.plus()); double sqpom=sqrt(pout.minus()); COM poperp=pout.x()+COM(0,1)*pout.y(); if (helout!=helin) { std::cerr<< "void j : Non-matching helicities\n"; } else if (helout==false) { // negative helicity if (pin.plus()>pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0]=sqpop*sqpip; cur[1]=sqpom*sqpip*conj(poperp)/abs(poperp); cur[2]=COM(0,1)*cur[1]; cur[3]=cur[0]; } else { // if backward double sqpim=sqrt(pin.minus()); cur[0]=-sqpom*sqpim*conj(poperp)/abs(poperp); cur[1]=-sqpim*sqpop; cur[2]=-COM(0,1)*cur[1]; cur[3]=-cur[0]; } } else { // positive helicity if (pin.plus()>pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0]=sqpop*sqpip; cur[1]=sqpom*sqpip*poperp/abs(poperp); cur[2]=-COM(0,1)*cur[1]; cur[3]=cur[0]; } else { // if backward double sqpim=sqrt(pin.minus()); cur[0]=-sqpom*sqpim*poperp/abs(poperp); cur[1]=-sqpim*sqpop; cur[2]=COM(0,1)*cur[1]; cur[3]=-cur[0]; } } CCurrent temp(cur[0],cur[1],cur[2],cur[3]); return temp; } // Current for void jio(HLV pin, bool helin, HLV pout, bool helout, current &cur) { cur[0] = 0.0; cur[1] = 0.0; cur[2] = 0.0; cur[3] = 0.0; if(helin!=helout){ std::cout<<__LINE__<<" "<<__FILE__< pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0] = sqpop * sqpip; cur[1] = sqpom * sqpip * conj(poperp) / abs(poperp); cur[2] = COM(0,1) * cur[1]; cur[3] = cur[0]; } else { double sqpim = sqrt(pin.minus()); cur[0] = -sqpom * sqpim * conj(poperp) / abs(poperp); cur[1] = -sqpim * sqpop; cur[2] = -COM(0,1) * cur[1]; cur[3] = -cur[0]; } } else { if (pin.plus() > pin.minus()) { // if forward double sqpip = sqrt(pin.plus()); cur[0] = sqpop * sqpip; cur[1] = sqpom * sqpip*poperp/abs(poperp); cur[2] = -COM(0,1)*cur[1]; cur[3] = cur[0]; } else { double sqpim = sqrt(pin.minus()); cur[0] = -sqpom * sqpim * poperp/abs(poperp); cur[1] = -sqpim * sqpop; cur[2] = COM(0,1)*cur[1]; cur[3] = -cur[0]; } } } // Current for void joo(HLV pi, bool heli, HLV pj, bool helj, current &cur) { // Zero our current cur[0] = 0.0; cur[1] = 0.0; cur[2] = 0.0; cur[3] = 0.0; if(helj){ std::cout<<__LINE__<<" "<<__FILE__< void joi(HLV pout, bool helout, HLV pin, bool helin, current &cur) { cur[0] = 0.0; cur[1] = 0.0; cur[2] = 0.0; cur[3] = 0.0; if(helin){ std::cout<<__LINE__<<" "<<__FILE__< pin.minus()) { // if forward double sqpip=sqrt(pin.plus()); cur[0] = sqpop * sqpip; cur[1] = sqpom * sqpip * poperp/abs(poperp); cur[2] = -COM(0,1)*cur[1]; cur[3] = cur[0]; } else { double sqpim = sqrt(pin.minus()); cur[0] = -sqpom*sqpim*poperp/abs(poperp); cur[1] = -sqpim*sqpop; cur[2] = COM(0,1)*cur[1]; cur[3] = -cur[0]; } } else { if (pin.plus() > pin.minus()) { // if forward double sqpip = sqrt(pin.plus()); cur[0] = sqpop * sqpip; cur[1] = sqpom * sqpip*conj(poperp)/abs(poperp); cur[2] = COM(0,1)*cur[1]; cur[3] = cur[0]; } else { double sqpim = sqrt(pin.minus()); cur[0] = -sqpom * sqpim * conj(poperp)/abs(poperp); cur[1] = -sqpim * sqpop; cur[2] = -COM(0,1)*cur[1]; cur[3] = -cur[0]; } } } -namespace { - /// @TODO unused function - // double jM2 (CLHEP::HepLorentzVector p1out, bool hel1out, CLHEP::HepLorentzVector p1in, bool hel1in, CLHEP::HepLorentzVector p2out, bool hel2out, CLHEP::HepLorentzVector p2in, bool hel2in) - // { - // CLHEP::HepLorentzVector q1=p1in-p1out; - // CLHEP::HepLorentzVector q2=-(p2in-p2out); - // current C1,C2; - // j (p1out,hel1out,p1in,hel1in, C1); - // j (p2out,hel2out,p2in,hel2in, C2); - - // std::cout << "# From Currents, C1 : ("< e+ nu, so that nu is lepton(6), e is anti-lepton(5) - // Need to swap e and nu for events with W- --> e- nubar! - if (helin==helout && hele==helnu) { - CLHEP::HepLorentzVector qa=pout+pe+pnu; - CLHEP::HepLorentzVector qb=pin-pe-pnu; - double ta(qa.m2()),tb(qb.m2()); - - current t65,vout,vin,temp2,temp3,temp5; - joo(pnu,helnu,pe,hele,t65); - vout[0]=pout.e(); - vout[1]=pout.x(); - vout[2]=pout.y(); - vout[3]=pout.z(); - vin[0]=pin.e(); - vin[1]=pin.x(); - vin[2]=pin.y(); - vin[3]=pin.z(); - - COM brac615=cdot(t65,vout); - COM brac645=cdot(t65,vin); - - // prod1565 and prod6465 are zero for Ws (not Zs)!! - // noalias(temp)=prod(trans(CurrentOutOut(pout,helout,pnu,helout)),metric); - joo(pout,helout,pnu,helout,temp2); - // noalias(temp2)=prod(temp,ctemp); - COM prod1665=cdot(temp2,t65); - // noalias(temp)=prod(trans(Current(pe,helin,pin,helin)),metric); - // noalias(temp2)=prod(temp,ctemp); - j(pe,helin,pin,helin,temp3); - COM prod5465=cdot(temp3,t65); - // noalias(temp)=prod(trans(Current(pnu,helin,pin,helin)),metric); - // noalias(temp2)=prod(temp,ctemp); - - joo(pout,helout,pe,helout,temp2); - j(pnu,helnu,pin,helin,temp3); - j(pout,helout,pin,helin,temp5); - - current term1,term2,term3,sum; - cmult(2.*brac615/ta+2.*brac645/tb,temp5,term1); - cmult(prod1665/ta,temp3,term2); - cmult(-prod5465/tb,temp2,term3); - - // cur=((2.*brac615*Current(pout,helout,pin,helin)+prod1565*Current(pe,helin,pin,helin)+prod1665*Current(pnu,helin,pin,helin))/ta + (2.*brac645*Current(pout,helout,pin,helin)-prod5465*CurrentOutOut(pout,helout,pe,helout)-prod6465*CurrentOutOut(pout,helout,pnu,helout))/tb); - // cur=((2.*brac615*temp5+prod1565*temp3+prod1665*temp4)/ta + (2.*brac645*temp5-prod5465*temp1-prod6465*temp2)/tb); - cadd(term1,term2,term3,sum); - // std::cout<<"sum: ("< e+ nu, so that nu is lepton(6), e is anti-lepton(5) - // Need to swap e and nu for events with W- --> e- nubar! - if (helin==helout && hele==helnu) { - CLHEP::HepLorentzVector qa=pout+pe+pnu; - CLHEP::HepLorentzVector qb=pin-pe-pnu; - double ta(qa.m2()),tb(qb.m2()); - - current t65,vout,vin,temp2,temp3,temp5; - joo(pnu,helnu,pe,hele,t65); - vout[0]=pout.e(); - vout[1]=pout.x(); - vout[2]=pout.y(); - vout[3]=pout.z(); - vin[0]=pin.e(); - vin[1]=pin.x(); - vin[2]=pin.y(); - vin[3]=pin.z(); - - COM brac615=cdot(t65,vout); - COM brac645=cdot(t65,vin); - - // prod1565 and prod6465 are zero for Ws (not Zs)!! - joo(pe,helout,pout,helout,temp2); // temp2 is <5|alpha|1> - COM prod5165=cdot(temp2,t65); - jio(pin,helin,pnu,helin,temp3); // temp3 is <4|alpha|6> - COM prod4665=cdot(temp3,t65); - - joo(pnu,helout,pout,helout,temp2); // temp2 is now <6|mu|1> - jio(pin,helin,pe,helin,temp3); // temp3 is now <4|mu|5> - jio(pin,helin,pout,helout,temp5); // temp5 is <4|mu|1> - - current term1,term2,term3,sum; - cmult(-2.*brac615/ta-2.*brac645/tb,temp5,term1); - cmult(-prod5165/ta,temp3,term2); - cmult(prod4665/tb,temp2,term3); - - // cur=((2.*brac615*Current(pout,helout,pin,helin)+prod1565*Current(pe,helin,pin,helin)+prod1665*Current(pnu,helin,pin,helin))/ta + (2.*brac645*Current(pout,helout,pin,helin)-prod5465*CurrentOutOut(pout,helout,pe,helout)-prod6465*CurrentOutOut(pout,helout,pnu,helout))/tb); - // cur=((2.*brac615*temp5+prod1565*temp3+prod1665*temp4)/ta + (2.*brac645*temp5-prod5465*temp1-prod6465*temp2)/tb); - cadd(term1,term2,term3,sum); - // std::cout<<"term1: ("<qenuQ scattering -// p1: quark (with W emittance) -// p2: Quark -{ - current mj1m,mj2p,mj2m; - CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; - CLHEP::HepLorentzVector q2=-(p2in-p2out); - - jW(p1out,false,pe,false,pnu,false,p1in,false,mj1m); - j(p2out,true,p2in,true,mj2p); - j(p2out,false,p2in,false,mj2m); - - // std::cout<<"jMW1: ("<qenuQ scattering -// p1: quark (with W emittance) -// p2: Quark -{ - current mj1m,mj2p,mj2m; - CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; - CLHEP::HepLorentzVector q2=-(p2in-p2out); - - jW(p1out,false,pe,false,pnu,false,p1in,false,mj1m); - jio(p2in,true,p2out,true,mj2p); - jio(p2in,false,p2out,false,mj2m); - - // std::cout<<"jMW1: ("<qenuQ scattering -// p1: quark (with W emittance) -// p2: Quark -{ - current mj1m,mj2p,mj2m; - CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; - CLHEP::HepLorentzVector q2=-(p2in-p2out); - - jWbar(p1out,false,pe,false,pnu,false,p1in,false,mj1m); - j(p2out,true,p2in,true,mj2p); - j(p2out,false,p2in,false,mj2m); - - // std::cout<<"jMW1: ("<qenuQ scattering -// p1: quark (with W emittance) -// p2: Quark -{ - current mj1m,mj2p,mj2m; - CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; - CLHEP::HepLorentzVector q2=-(p2in-p2out); - - jWbar(p1out,false,pe,false,pnu,false,p1in,false,mj1m); - jio(p2in,true,p2out,true,mj2p); - jio(p2in,false,p2out,false,mj2m); - - // std::cout<<"jMW1: ("<qenug scattering -// p1: quark -// p2: gluon -{ - CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; - CLHEP::HepLorentzVector q2=-(p2in-p2out); - current mj1m,mj2p,mj2m; - - jW(p1out,false,pe,false,pnu,false,p1in,false,mj1m); - - j(p2out,true,p2in,true,mj2p); - j(p2out,false,p2in,false,mj2m); - - // mj1m.mj2p - - COM Mmp=cdot(mj1m,mj2p); - - // mj1m.mj2m - COM Mmm=cdot(mj1m,mj2m); - - double ratio; // p2-/pb- in the notes - // if (p2in.plus()>0) // if the gluon is the positive - if (p2in.pz()>0.) // if the gluon is the positive - ratio=p2out.plus()/p2in.plus(); - else // the gluon is the negative - ratio=p2out.minus()/p2in.minus(); - - - double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; - - // sum of spinor strings ||^2 - double a2Mmp=abs2(Mmp); - double a2Mmm=abs2(Mmm); - double sst = nonflipcolourmult*(a2Mmp+a2Mmm); - // double sstsave=sst; - -// // Leave division by colour and Helicity avg until Tree files - // Leave multi. of couplings to later - // Multiply by Cf*Ca=4 - return 4.*sst/(q1.m2()*q2.m2()); - -} - -double jMWqbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector pe, CLHEP::HepLorentzVector pnu,CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) -// Calculates the square of the current contractions for qg->qenug scattering -// p1: quark -// p2: gluon -{ - CLHEP::HepLorentzVector q1=p1in-p1out-pe-pnu; - CLHEP::HepLorentzVector q2=-(p2in-p2out); - current mj1m,mj2p,mj2m; - - jWbar(p1out,false,pe,false,pnu,false,p1in,false,mj1m); - - j(p2out,true,p2in,true,mj2p); - j(p2out,false,p2in,false,mj2m); - - // mj1m.mj2p - - COM Mmp=cdot(mj1m,mj2p); - - // mj1m.mj2m - COM Mmm=cdot(mj1m,mj2m); - - double ratio; // p2-/pb- in the notes - // if (p2in.plus()>0) // if the gluon is the positive - if (p2in.pz()>0.) // if the gluon is the positive - ratio=p2out.plus()/p2in.plus(); - else // the gluon is the negative - ratio=p2out.minus()/p2in.minus(); - - - double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; - - // sum of spinor strings ||^2 - double a2Mmp=abs2(Mmp); - double a2Mmm=abs2(Mmm); - double sst = nonflipcolourmult*(a2Mmp+a2Mmm); - // double sstsave=sst; - -// // Leave division by colour and Helicity avg until Tree files - // Leave multi. of couplings to later - // Multiply by Cf*Ca=4 - return 4.*sst/(q1.m2()*q2.m2()); - -} double jM2qQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in) { // std::cerr<<"Current: "<0) // if the gluon is the positive if (p2in.pz()>0.) // if the gluon is the positive ratio=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio=p2out.minus()/p2in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; // sum of spinor strings ||^2 double a2Mmp=abs2(Mmp); double a2Mmm=abs2(Mmm); double a2Mpp=abs2(Mpp); double a2Mpm=abs2(Mpm); double sst = nonflipcolourmult*(a2Mpp+a2Mpm+a2Mmp+a2Mmm); // double sstsave=sst; // std::cout <<"ratio: "<0) // if the gluon is the positive if (p2in.pz()>0.) // if the gluon is the positive ratio=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio=p2out.minus()/p2in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; // sum of spinor strings ||^2 double a2Mmp=abs2(Mmp); double a2Mmm=abs2(Mmm); double a2Mpp=abs2(Mpp); double a2Mpm=abs2(Mpm); double sst = nonflipcolourmult*(a2Mpp+a2Mpm+a2Mmp+a2Mmm); // double sstsave=sst; // std::cout <<"ratio: "<1.) // if the gluon is the positive. Should have been a // // test against 0, but 1. is better if (p1in.pz()>0.) // a much better test ratio1=p1out.plus()/p1in.plus(); else // the gluon is the negative ratio1=p1out.minus()/p1in.minus(); double nonflipcolourmult1=(1.-1./9.)/2.*(ratio1+1./ratio1)+1./9.; double ratio2; // p2-/pb- in the notes if (p2in.pz()>0.) // a much better test ratio2=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio2=p2out.minus()/p2in.minus(); double nonflipcolourmult2=(1.-1./9.)/2.*(ratio2+1./ratio2)+1./9.; // sum of spinor strings ||^2 double a2Mmp=abs2(Mmp); double a2Mmm=abs2(Mmm); double a2Mpp=abs2(Mpp); double a2Mpm=abs2(Mpm); double sst = nonflipcolourmult1*nonflipcolourmult2*(a2Mpp+a2Mpm+a2Mmp+a2Mmm); // double sstsave=sst; // std::cout <<"ratio: "< 16 pi mt^2/v alphas, and we divide by a factor 4 at the amp sqaured level later which I absorb here (i.e. I divide by 2) return 8.*M_PI*mt*mt/v*(-cdot(C1,q2)*cdot(C2,q1)*A1(-vq1,vq2,mt)-cdot(C1,C2)*A2(-vq1,vq2,mt)); else return 8.*M_PI*mt*mt/v*(-cdot(C1,q2)*cdot(C2,q1)*A1(-vq1,vq2,mt)-cdot(C1,C2)*A2(-vq1,vq2,mt)) + 8.*M_PI*mb*mb/v*(-cdot(C1,q2)*cdot(C2,q1)*A1(-vq1,vq2,mb)-cdot(C1,C2)*A2(-vq1,vq2,mb)); } } } // namespace anonymous double MH2qQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { // CLHEP::HepLorentzVector q1=p1in-p1out; // CLHEP::HepLorentzVector q2=-(p2in-p2out); current j1p,j1m,j2p,j2m, q1v, q2v; j (p1out,true,p1in,true,j1p); j (p1out,false,p1in,false,j1m); j (p2out,true,p2in,true,j2p); j (p2out,false,p2in,false,j2m); to_current(q1, q1v); to_current(q2, q2v); COM Mmp=cHdot(j1m,j2p,q1v,q2v,mt, incBot, mb); COM Mmm=cHdot(j1m,j2m,q1v,q2v,mt, incBot, mb); COM Mpp=cHdot(j1p,j2p,q1v,q2v,mt, incBot, mb); COM Mpm=cHdot(j1p,j2m,q1v,q2v,mt, incBot, mb); double sst=abs2(Mmp)+abs2(Mmm)+abs2(Mpp)+abs2(Mpm); // return (4./3.)*(4./3.)*sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); return sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); } double MH2qQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { // CLHEP::HepLorentzVector q1=p1in-p1out; // CLHEP::HepLorentzVector q2=-(p2in-p2out); current j1p,j1m,j2p,j2m,q1v,q2v; j (p1out,true,p1in,true,j1p); j (p1out,false,p1in,false,j1m); jio (p2in,true,p2out,true,j2p); jio (p2in,false,p2out,false,j2m); to_current(q1, q1v); to_current(q2, q2v); COM Mmp=cHdot(j1m,j2p,q1v,q2v,mt, incBot, mb); COM Mmm=cHdot(j1m,j2m,q1v,q2v,mt, incBot, mb); COM Mpp=cHdot(j1p,j2p,q1v,q2v,mt, incBot, mb); COM Mpm=cHdot(j1p,j2m,q1v,q2v,mt, incBot, mb); double sst=abs2(Mmp)+abs2(Mmm)+abs2(Mpp)+abs2(Mpm); // return (4./3.)*(4./3.)*sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); return sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); } double MH2qbarQ (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { // CLHEP::HepLorentzVector q1=p1in-p1out; // CLHEP::HepLorentzVector q2=-(p2in-p2out); current j1p,j1m,j2p,j2m,q1v,q2v; jio (p1in,true,p1out,true,j1p); jio (p1in,false,p1out,false,j1m); j (p2out,true,p2in,true,j2p); j (p2out,false,p2in,false,j2m); to_current(q1, q1v); to_current(q2, q2v); COM Mmp=cHdot(j1m,j2p,q1v,q2v,mt, incBot, mb); COM Mmm=cHdot(j1m,j2m,q1v,q2v,mt, incBot, mb); COM Mpp=cHdot(j1p,j2p,q1v,q2v,mt, incBot, mb); COM Mpm=cHdot(j1p,j2m,q1v,q2v,mt, incBot, mb); double sst=abs2(Mmp)+abs2(Mmm)+abs2(Mpp)+abs2(Mpm); // return (4./3.)*(4./3.)*sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); return sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); } double MH2qbarQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { // CLHEP::HepLorentzVector q1=p1in-p1out; // CLHEP::HepLorentzVector q2=-(p2in-p2out); current j1p,j1m,j2p,j2m,q1v,q2v; jio (p1in,true,p1out,true,j1p); jio (p1in,false,p1out,false,j1m); jio (p2in,true,p2out,true,j2p); jio (p2in,false,p2out,false,j2m); to_current(q1, q1v); to_current(q2, q2v); COM Mmp=cHdot(j1m,j2p,q1v,q2v,mt, incBot, mb); COM Mmm=cHdot(j1m,j2m,q1v,q2v,mt, incBot, mb); COM Mpp=cHdot(j1p,j2p,q1v,q2v,mt, incBot, mb); COM Mpm=cHdot(j1p,j2m,q1v,q2v,mt, incBot, mb); double sst=abs2(Mmp)+abs2(Mmm)+abs2(Mpp)+abs2(Mpm); // return (4./3.)*(4./3.)*sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); return sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); } double MH2qg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) // q~p1 g~p2 (i.e. ALWAYS p1 for quark, p2 for gluon) // should be called with q1 meant to be contracted with p2 in first part of vertex // (i.e. if g is backward, q1 is forward) { current j1p,j1m,j2p,j2m,q1v,q2v; j (p1out,true,p1in,true,j1p); j (p1out,false,p1in,false,j1m); j (p2out,true,p2in,true,j2p); j (p2out,false,p2in,false,j2m); to_current(q1, q1v); to_current(q2, q2v); // First, calculate the non-flipping amplitudes: COM Mpp=cHdot(j1p,j2p,q1v,q2v,mt, incBot, mb); COM Mpm=cHdot(j1p,j2m,q1v,q2v,mt, incBot, mb); COM Mmp=cHdot(j1m,j2p,q1v,q2v,mt, incBot, mb); COM Mmm=cHdot(j1m,j2m,q1v,q2v,mt, incBot, mb); //cout << "Bits in MH2qg: " << Mpp << " " << Mpm << " " << Mmp << " " << Mmm << endl; double ratio; // p2-/pb- in the notes // if (p2in.plus()>0) // if the gluon is the positive if (p2in.pz()>0) // if the gluon is the positive ratio=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio=p2out.minus()/p2in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; double sst=nonflipcolourmult*(abs2(Mmp)+abs2(Mmm)+abs2(Mpp)+abs2(Mpm)); // Cf*Ca=4 // return 4.*sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); return sst/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); } double MH2qbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) // qbar~p1 g~p2 (i.e. ALWAYS p1 for anti-quark, p2 for gluon) // should be called with q1 meant to be contracted with p2 in first part of vertex // (i.e. if g is backward, q1 is forward) { current j1p,j1m,j2p,j2m,q1v,q2v; jio (p1in,true,p1out,true,j1p); jio (p1in,false,p1out,false,j1m); j (p2out,true,p2in,true,j2p); j (p2out,false,p2in,false,j2m); to_current(q1, q1v); to_current(q2, q2v); // First, calculate the non-flipping amplitudes: COM amp,amm,apm,app; app=cHdot(j1p,j2p,q1v,q2v,mt, incBot, mb); apm=cHdot(j1p,j2m,q1v,q2v,mt, incBot, mb); amp=cHdot(j1m,j2p,q1v,q2v,mt, incBot, mb); amm=cHdot(j1m,j2m,q1v,q2v,mt, incBot, mb); double MH2sum = abs2(app)+abs2(amm)+abs2(apm)+abs2(amp); double ratio; // p2-/pb- in the notes // if (p2in.plus()>0) // if the gluon is the positive if (p2in.pz()>0) // if the gluon is the positive ratio=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio=p2out.minus()/p2in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; MH2sum*=nonflipcolourmult; // Cf*Ca=4 // return 4.*MH2sum/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); return MH2sum/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); } double MH2gg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) // g~p1 g~p2 // should be called with q1 meant to be contracted with p2 in first part of vertex // (i.e. if g is backward, q1 is forward) { current j1p,j1m,j2p,j2m,q1v,q2v; j (p1out,true,p1in,true,j1p); j (p1out,false,p1in,false,j1m); j (p2out,true,p2in,true,j2p); j (p2out,false,p2in,false,j2m); to_current(q1, q1v); to_current(q2, q2v); // First, calculate the non-flipping amplitudes: COM amp,amm,apm,app; app=cHdot(j1p,j2p,q1v,q2v,mt, incBot, mb); apm=cHdot(j1p,j2m,q1v,q2v,mt, incBot, mb); amp=cHdot(j1m,j2p,q1v,q2v,mt, incBot, mb); amm=cHdot(j1m,j2m,q1v,q2v,mt, incBot, mb); double MH2sum = abs2(app)+abs2(amm)+abs2(apm)+abs2(amp); double ratio1; // p1-/pa- in the notes // if (p1in.plus()>0) // if the gluon is the positive if (p1in.pz()>0.) // if the gluon is the positive ratio1=p1out.plus()/p1in.plus(); else // the gluon is the negative ratio1=p1out.minus()/p1in.minus(); double nonflipcolourmult1=(1.-1./9.)/2.*(ratio1+1./ratio1)+1./9.; double ratio2; // p2-/pb- in the notes // if (p2in.plus()>0) // if the gluon is the positive if (p2in.pz()>0.) // if the gluon is the positive ratio2=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio2=p2out.minus()/p2in.minus(); double nonflipcolourmult2=(1.-1./9.)/2.*(ratio2+1./ratio2)+1./9.; MH2sum*=nonflipcolourmult1*nonflipcolourmult2; // Ca*Ca=9 // return 9.*MH2sum/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); return MH2sum/((p1in-p1out).m2()*(p2in-p2out).m2()*q1.m2()*q2.m2()); } // // Z's stuff // void jZ(HLV pin, HLV pout, HLV pem, HLV pep, bool HelPartons, bool HelLeptons, current cur) { // // Init current to zero // cur[0] = 0.0; // cur[1] = 0.0; // cur[2] = 0.0; // cur[3] = 0.0; // // Temporary variables // COM temp; // current Term_1, Term_2, Term_3, Term_4, J_temp, TempCur1, TempCur2; // // Momentum of virtual gluons aroun weak boson emission site // HLV qa = pout + pep + pem; // HLV qb = pin - pep - pem; // double ta = qa.m2(); // double tb = qb.m2(); // // Out-Out currents: // current Em_Ep, Out_Em, Out_Ep; // // Other currents: // current Out_In, Em_In, Ep_In; // joi(pout, HelPartons, pin, HelPartons, Out_In); // joi(pem, HelLeptons, pin, HelPartons, Em_In); // joi(pep, HelLeptons, pin, HelPartons, Ep_In); // joo(pem, HelLeptons, pep, HelLeptons, Em_Ep); // joo(pout, HelPartons, pem, HelLeptons, Out_Em); // joo(pout, HelPartons, pep, HelLeptons, Out_Ep); // if (HelLeptons == HelPartons) { // temp = 2.0 * cdot(pout, Em_Ep); // cmult(temp / ta, Out_In, Term_1); // temp = cdot(Out_Em, Em_Ep); // cmult(temp / ta , Em_In, Term_2); // temp = 2.0 * cdot(pin, Em_Ep); // cmult(temp / tb, Out_In, Term_3); // temp = -cdot(Ep_In, Em_Ep); // cmult(temp / tb, Out_Ep, Term_4); // cadd(Term_1, Term_2, Term_3, Term_4, J_temp); // cur[0] = J_temp[0]; // cur[1] = J_temp[1]; // cur[2] = J_temp[2]; // cur[3] = J_temp[3]; // } // else { // if (HelPartons == true) { // temp = 2.0 * cdot(pout, Em_Ep); // cmult(temp / ta, Out_In, Term_1); // joo(pout, true, pep, true, TempCur1); // joi(pep, true, pin, true, TempCur2); // temp = cdot(TempCur1, Em_Ep); // cmult(temp / ta , TempCur2, Term_2); // temp = 2.0 * cdot(pin, Em_Ep); // cmult(temp / tb, Out_In, Term_3); // joo(pout, true, pem, true, TempCur1); // joi(pem, true, pin, true, TempCur2); // temp = -cdot(TempCur2, Em_Ep); // cmult(temp / tb, TempCur1, Term_4); // cadd(Term_1, Term_2, Term_3, Term_4, J_temp); // cur[0] = J_temp[0]; // cur[1] = J_temp[1]; // cur[2] = J_temp[2]; // cur[3] = J_temp[3]; // } // else { // temp = 2.0 * cdot(pout, Em_Ep); // cmult(temp / ta, Out_In, Term_1); // joo(pout, false, pep, false, TempCur1); // joi(pep, false, pin, false, TempCur2); // temp = cdot(TempCur1, Em_Ep); // cmult(temp / ta, TempCur2, Term_2); // temp = 2.0 * cdot(pin, Em_Ep); // cmult(temp / tb, Out_In, Term_3); // joo(pout, false, pem, false, TempCur1); // joi(pem, false, pin, false, TempCur2); // temp = -cdot(TempCur2, Em_Ep); // cmult(temp / tb, TempCur1, Term_4); // cadd(Term_1, Term_2, Term_3, Term_4, J_temp); // cur[0] = J_temp[0]; // cur[1] = J_temp[1]; // cur[2] = J_temp[2]; // cur[3] = J_temp[3]; // } // } // } // void jZbar(HLV pin, HLV pout, HLV pem, HLV pep, bool HelPartons, bool HelLeptons, current cur) { // // Init current to zero // cur[0] = 0.0; // cur[1] = 0.0; // cur[2] = 0.0; // cur[3] = 0.0; // // Temporary variables // COM temp; // current Term_1, Term_2, Term_3, Term_4, J_temp, TempCur1, TempCur2; // // Transfered 4-momenta // HLV qa = pout + pep + pem; // HLV qb = pin - pep - pem; // // The square of the transfered 4-momenta // double ta = qa.m2(); // double tb = qb.m2(); // // Out-Out currents: // current Em_Ep, Em_Out, Ep_Out; // // In-Out currents: // current In_Out, In_Em, In_Ep; // // Safe to use the currents since helicity structure is ok // if (HelPartons == HelLeptons) { // jio(pin, HelPartons, pout, HelPartons, In_Out); // joo(pem, HelLeptons, pep, HelLeptons, Em_Ep); // jio(pin, HelPartons, pem, HelLeptons, In_Em); // jio(pin, HelPartons, pep, HelLeptons, In_Ep); // joo(pem, HelLeptons, pout, HelPartons, Em_Out); // joo(pep, HelLeptons, pout, HelPartons, Ep_Out); // } // else { // jio(pin, HelPartons, pout, HelPartons, In_Out); // joo(pem, HelLeptons, pep, HelLeptons, Em_Ep); // In_Em[0] = 0.0; // In_Em[1] = 0.0; // In_Em[2] = 0.0; // In_Em[3] = 0.0; // In_Ep[0] = 0.0; // In_Ep[1] = 0.0; // In_Ep[2] = 0.0; // In_Ep[3] = 0.0; // Em_Out[0] = 0.0; // Em_Out[1] = 0.0; // Em_Out[2] = 0.0; // Em_Out[3] = 0.0; // Ep_Out[0] = 0.0; // Ep_Out[1] = 0.0; // Ep_Out[2] = 0.0; // Ep_Out[3] = 0.0; // } // if (HelLeptons == HelPartons) { // temp = 2.0 * cdot(pout, Em_Ep); // cmult(temp / ta, In_Out, Term_1); // temp = cdot(Ep_Out, Em_Ep); // cmult(temp / ta, In_Ep, Term_2); // temp = 2.0 * cdot(pin, Em_Ep); // cmult(temp / tb, In_Out, Term_3); // temp = - cdot(In_Em, Em_Ep); // cmult(temp / tb, Em_Out, Term_4); // cadd(Term_1, Term_2, Term_3, Term_4, J_temp); // cur[0] = J_temp[0]; // cur[1] = J_temp[1]; // cur[2] = J_temp[2]; // cur[3] = J_temp[3]; // } // else { // if (HelPartons == true) { // temp = 2.0 * cdot(pout, Em_Ep); // cmult(temp / ta, In_Out, Term_1); // joo(pem, true, pout, true, TempCur1); // jio(pin, true, pem, true, TempCur2); // temp = cdot(TempCur1, Em_Ep); // cmult(temp / ta , TempCur2, Term_2); // temp = 2.0 * cdot(pin, Em_Ep); // cmult(temp / tb, In_Out, Term_3); // joo(pep, true, pout, true, TempCur1); // jio(pin, true, pep, true, TempCur2); // temp = - cdot(TempCur2, Em_Ep); // cmult(temp / tb, TempCur1, Term_4); // cadd(Term_1, Term_2, Term_3, Term_4, J_temp); // cur[0] = J_temp[0]; // cur[1] = J_temp[1]; // cur[2] = J_temp[2]; // cur[3] = J_temp[3]; // } // else { // temp = 2.0 * cdot(pout, Em_Ep); // cmult(temp / ta, In_Out, Term_1); // joo(pem, false, pout, false, TempCur1); // jio(pin, false, pem, false, TempCur2); // temp = cdot(TempCur1, Em_Ep); // cmult(temp / ta , TempCur2, Term_2); // temp = 2.0 * cdot(pin, Em_Ep); // cmult(temp / tb, In_Out, Term_3); // joo(pep, false, pout, false, TempCur1); // jio(pin, false, pep, false, TempCur2); // temp = - cdot(TempCur2, Em_Ep); // cmult(temp / tb, TempCur1, Term_4); // cadd(Term_1, Term_2, Term_3, Term_4, J_temp); // cur[0] = J_temp[0]; // cur[1] = J_temp[1]; // cur[2] = J_temp[2]; // cur[3] = J_temp[3]; // } // } // } // // Progagators // COM PZ(double s) { // double MZ, GammaZ; // MZ = 9.118800e+01; // Mass of the mediating gauge boson // GammaZ = 2.441404e+00; // Z peak width // // Return Z Prop value // return 1.0 / (s - MZ * MZ + COM(0.0, 1.0) * GammaZ * MZ); // } // COM PG(double s) { // return 1.0 / s; // } // // Non-gluonic with pa emitting // std::vector jMZqQ (HLV pa, HLV pb, HLV p1, HLV p2, HLV pep, HLV pem, std::vector VProducts, std::vector < std::vector > Virtuals, int aptype, int bptype, bool UseVirtuals, bool BottomLineEmit) { // std::vector ScaledWeights; // double Sum; // // Propagator factors // COM PZs = PZ((pep + pem).m2()); // COM PGs = PG((pep + pem).m2()); // // Emitting current initialisation // current j1pptop, j1pmtop; // Emission from top line // current j1ppbot, j1pmbot; // Emission from bottom line // // Non-emitting current initialisation // current j2ptop, j2mtop; // Emission from top line // current j2pbot, j2mbot; // Emission from bottom line // // Currents for top emission // // Upper current calculations // // if a is a quark // if (aptype > 0) { // jZ(pa, p1, pem, pep, true, true, j1pptop); // jZ(pa, p1, pem, pep, true, false, j1pmtop); // } // // if a is an antiquark // else { // jZbar(pa, p1, pem, pep, true, true, j1pptop); // jZbar(pa, p1, pem, pep, true, false, j1pmtop); // } // // Lower current calculations // // if b is a quark // if (bptype > 0) { // joi(p2, true, pb, true, j2ptop); // joi(p2, false, pb, false, j2mtop); // } // // if b is an antiquark // else { // jio(pb, true, p2, true, j2ptop); // jio(pb, false, p2, false, j2mtop); // } // // Currents for bottom emission // // Lower current calculations // if (bptype > 0) { // jZ(pb, p2, pem, pep, true, true, j1ppbot); // jZ(pb, p2, pem, pep, true, false, j1pmbot); // } // else { // jZbar(pb, p2, pem, pep, true, true, j1ppbot); // jZbar(pb, p2, pem, pep, true, false, j1pmbot); // } // // Upper current calculations // if (aptype > 0) { // joi(p1, true, pa, true, j2pbot); // joi(p1, false, pa, false, j2mbot); // } // else { // jio(pa, true, p1, true, j2pbot); // jio(pa, false, p1, false, j2mbot); // } // COM Coeff[2][8]; // if (!Interference) { // double ZCharge_a_P = Zq(aptype, true); // double ZCharge_a_M = Zq(aptype, false); // double ZCharge_b_P = Zq(bptype, true); // double ZCharge_b_M = Zq(bptype, false); // if (BottomLineEmit) { // // Emission from top-line quark (pa/p1 line) // Coeff[0][0] = (ZCharge_a_P * Zep * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pptop, j2ptop); // Coeff[0][1] = (ZCharge_a_P * Zep * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pptop, j2mtop); // Coeff[0][2] = (ZCharge_a_P * Zem * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pmtop, j2ptop); // Coeff[0][3] = (ZCharge_a_P * Zem * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pmtop, j2mtop); // Coeff[0][4] = (ZCharge_a_M * Zem * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pptop, j2ptop)); // Coeff[0][5] = (ZCharge_a_M * Zem * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pptop, j2mtop)); // Coeff[0][6] = (ZCharge_a_M * Zep * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pmtop, j2ptop)); // Coeff[0][7] = (ZCharge_a_M * Zep * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pmtop, j2mtop)); // } // else { // // Emission from bottom-line quark (pb/p2 line) // Coeff[1][0] = (ZCharge_b_P * Zep * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1ppbot, j2pbot); // Coeff[1][7] = (ZCharge_b_P * Zep * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1ppbot, j2mbot); // Coeff[1][2] = (ZCharge_b_P * Zem * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1pmbot, j2pbot); // Coeff[1][5] = (ZCharge_b_P * Zem * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1pmbot, j2mbot); // Coeff[1][4] = (ZCharge_b_M * Zem * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1ppbot, j2pbot)); // Coeff[1][3] = (ZCharge_b_M * Zem * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1ppbot, j2mbot)); // Coeff[1][6] = (ZCharge_b_M * Zep * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1pmbot, j2pbot)); // Coeff[1][1] = (ZCharge_b_M * Zep * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1pmbot, j2mbot)); // } // } // // Else calculate all the possiblities // else { // double ZCharge_a_P = Zq(aptype, true); // double ZCharge_a_M = Zq(aptype, false); // double ZCharge_b_P = Zq(bptype, true); // double ZCharge_b_M = Zq(bptype, false); // // Emission from top-line quark (pa/p1 line) // Coeff[0][0] = (ZCharge_a_P * Zep * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pptop, j2ptop); // Coeff[0][1] = (ZCharge_a_P * Zep * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pptop, j2mtop); // Coeff[0][2] = (ZCharge_a_P * Zem * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pmtop, j2ptop); // Coeff[0][3] = (ZCharge_a_P * Zem * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pmtop, j2mtop); // Coeff[0][4] = (ZCharge_a_M * Zem * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pptop, j2ptop)); // Coeff[0][5] = (ZCharge_a_M * Zem * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pptop, j2mtop)); // Coeff[0][6] = (ZCharge_a_M * Zep * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pmtop, j2ptop)); // Coeff[0][7] = (ZCharge_a_M * Zep * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pmtop, j2mtop)); // // Emission from bottom-line quark (pb/p2 line) // Coeff[1][0] = (ZCharge_b_P * Zep * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1ppbot, j2pbot); // Coeff[1][7] = (ZCharge_b_P * Zep * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1ppbot, j2mbot); // Coeff[1][2] = (ZCharge_b_P * Zem * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1pmbot, j2pbot); // Coeff[1][5] = (ZCharge_b_P * Zem * PZs * RWeak + Gq(bptype) * PGs) * cdot(j1pmbot, j2mbot); // Coeff[1][4] = (ZCharge_b_M * Zem * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1ppbot, j2pbot)); // Coeff[1][3] = (ZCharge_b_M * Zem * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1ppbot, j2mbot)); // Coeff[1][6] = (ZCharge_b_M * Zep * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1pmbot, j2pbot)); // Coeff[1][1] = (ZCharge_b_M * Zep * PZs * RWeak + Gq(bptype) * PGs) * conj(cdot(j1pmbot, j2mbot)); // } // // Find the numbers of scales // int ScaleCount; // #if calcscaleunc // ScaleCount = 20; // #else // ScaleCount = 1; // #endif // // For each scale... // for (int j = 0; j < ScaleCount; j++) { // Sum = 0.0; // // If we want to compare back to the W's code only emit from one quark and only couple to left handed particles // // virtuals arent here since they are calculated and included in weight() call. // if (!Interference) { // if (BottomLineEmit) for (int i = 0; i < 8; i++) Sum += abs2(Coeff[1][i]) * VProducts.at(1); // else for (int i = 0; i < 8; i++) Sum += abs2(Coeff[0][i]) * VProducts.at(0); // } // // Else work out the full interference // else { // // For the full calculation... // if (UseVirtuals) { // for (int i = 0; i < 8; i++) { // Sum += abs2(Coeff[0][i]) * VProducts.at(0) * Virtuals.at(j).at(0) // + abs2(Coeff[1][i]) * VProducts.at(1) * Virtuals.at(j).at(1) // + 2.0 * real(Coeff[0][i] * conj(Coeff[1][i])) * VProducts.at(2) * Virtuals.at(j).at(2); // } // } // // For the tree level calculation... // else { // for (int i = 0; i < 8; i++) { // Sum += abs2(Coeff[0][i]) * VProducts.at(0) // + abs2(Coeff[1][i]) * VProducts.at(1) // + 2.0 * real(Coeff[0][i] * conj(Coeff[1][i])) * VProducts.at(2); // } // } // } // // Add this to the vector to be returned with the other factors of C_A and the helicity sum/average factors. // ScaledWeights.push_back(Sum / 18.0); // } // // Return all the scale values // return ScaledWeights; // } // // Semi-gluonic with pa emitting // std::vector jMZqg (HLV pa, HLV pb, HLV p1, HLV p2, HLV pep, HLV pem, std::vector VProducts, std::vector < std::vector > Virtuals, int aptype, int bptype, bool UseVirtuals, bool BottomLineEmit) { // COM Coeff[8]; // double Sum; // std::vector ScaledWeights; // COM PZs = PZ((pep + pem).m2()); // COM PGs = PG((pep + pem).m2()); // // Emitting current initialisation - Emission from top line // current j1pptop, j1pmtop; // // Non-emitting current initialisation - Emission from top line // current j2ptop, j2mtop; // // Currents for top emission // // Upper current calculations // if (aptype > 0) { // jZ (pa, p1, pem, pep, true, true, j1pptop); // jZ (pa, p1, pem, pep, true, false, j1pmtop); // } // else { // jZbar(pa, p1, pem, pep, true, true, j1pptop); // jZbar(pa, p1, pem, pep, true, false, j1pmtop); // } // // Lower current calculations // joi(p2, true, pb, true, j2ptop); // joi(p2, false, pb, false, j2mtop); // // Calculate all the possiblities // double ZCharge_a_P = Zq(aptype, true); // double ZCharge_a_M = Zq(aptype, false); // // Emission from top-line quark (pa/p1 line) // Coeff[0] = (ZCharge_a_P * Zep * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pptop, j2ptop); // Coeff[1] = (ZCharge_a_P * Zep * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pptop, j2mtop); // Coeff[2] = (ZCharge_a_P * Zem * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pmtop, j2ptop); // Coeff[3] = (ZCharge_a_P * Zem * PZs * RWeak + Gq(aptype) * PGs) * cdot(j1pmtop, j2mtop); // Coeff[4] = (ZCharge_a_M * Zem * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pptop, j2ptop)); // Coeff[5] = (ZCharge_a_M * Zem * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pptop, j2mtop)); // Coeff[6] = (ZCharge_a_M * Zep * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pmtop, j2ptop)); // Coeff[7] = (ZCharge_a_M * Zep * PZs * RWeak + Gq(aptype) * PGs) * conj(cdot(j1pmtop, j2mtop)); // // Calculate gluon colour accelerated factor // double CAMFactor, z; // // If b is a forward moving gluon define z (C.F. multiple jets papers) // if (pb.pz() > 0) z = p2.plus() / pb.plus(); // else z = p2.minus() / pb.minus(); // CAMFactor = (1.0 - 1.0 / 9.0) / 2.0 * (z + 1.0 / z) + 1.0 / 9.0; // // Find the numbers of scales // int ScaleCount; // #if calcscaleunc // ScaleCount = 20; // #else // ScaleCount = 1; // #endif // // For each scale... // for (int j = 0; j < ScaleCount; j++) { // Sum = 0.0; // // If we dont want the interference // if (!Interference) for (int i = 0; i < 8; i++) Sum += abs2(Coeff[i]) * VProducts.at(0); // // Else work out the full interference // else { // if (UseVirtuals) { // for (int i = 0; i < 8; i++) Sum += abs2(Coeff[i]) * VProducts.at(0) * Virtuals.at(j).at(0); // } // else { // for (int i = 0; i < 8; i++) Sum += abs2(Coeff[i]) * VProducts.at(0); // } // } // // Add this to the vector to be returned with the other factors of C_A, the colour accelerated factor and the helicity sum/average factors.: (4/3)*3/32 // ScaledWeights.push_back(CAMFactor * Sum / 8.0); // } // return ScaledWeights; // } // // Electroweak Charge Functions // double Zq (int PID, bool Helcitiy) { // double temp; // // Positive Spin // if (Helcitiy == true) { // if (PID == 1 || PID == 3 || PID == 5) temp = (+ 1.0 * stw2 / 3.0) / ctw; // if (PID == 2 || PID == 4) temp = (- 2.0 * stw2 / 3.0) / ctw; // if (PID == -1 || PID == -3 || PID == -5) temp = (- 1.0 * stw2 / 3.0) / ctw; // if (PID == -2 || PID == -4) temp = (+ 2.0 * stw2 / 3.0) / ctw; // // If electron or positron // if (PID == 7 || PID == -7) temp = Zep; // } // // Negative Spin // else { // if (PID == 1 || PID == 3 || PID == 5) temp = (-0.5 + 1.0 * stw2 / 3.0) / ctw; // if (PID == 2 || PID == 4) temp = ( 0.5 - 2.0 * stw2 / 3.0) / ctw; // if (PID == -1 || PID == -3 || PID == -5) temp = ( 0.5 - 1.0 * stw2 / 3.0) / ctw; // if (PID == -2 || PID == -4) temp = (-0.5 + 2.0 * stw2 / 3.0) / ctw; // // If electron or positron // if (PID == 7 || PID == -7) temp = Zem; // } // return temp; // } // double Gq (int PID) { // if (!VirtualPhoton) return 0.0; // if (PID == -1) return 1.0 * ee / 3.0; // if (PID == -2) return -2.0 * ee / 3.0; // if (PID == -3) return 1.0 * ee / 3.0; // if (PID == -4) return -2.0 * ee / 3.0; // if (PID == -5) return 1.0 * ee / 3.0; // if (PID == 1) return -1.0 * ee / 3.0; // if (PID == 2) return 2.0 * ee / 3.0; // if (PID == 3) return -1.0 * ee / 3.0; // if (PID == 4) return 2.0 * ee / 3.0; // if (PID == 5) return -1.0 * ee / 3.0; // std::cout << "ERROR! No Electroweak Charge Found at line " << __LINE__ << "..." << std::endl; // return 0.0; // } namespace { CCurrent jH (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pin, bool helin, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { CCurrent j2 = j(pout,helout,pin,helin); CCurrent jq2(q2.e(),q2.px(),q2.py(),q2.pz()); if(mt == infinity) return ((q1.dot(q2))*j2 - j2.dot(q1)*jq2)/(3*M_PI*v); else { if(incBot) return (-16.*M_PI*mb*mb/v*j2.dot(q1)*jq2*A1(-q1,q2,mb)-16.*M_PI*mb*mb/v*j2*A2(-q1,q2,mb)) + (-16.*M_PI*mt*mt/v*j2.dot(q1)*jq2*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j2*A2(-q1,q2,mt)); else return (-16.*M_PI*mt*mt/v*j2.dot(q1)*jq2*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j2*A2(-q1,q2,mt)); } } CCurrent jioH (CLHEP::HepLorentzVector pin, bool helin, CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { CCurrent j2 = jio(pin,helin,pout,helout); CCurrent jq2(q2.e(),q2.px(),q2.py(),q2.pz()); if(mt == infinity) return ((q1.dot(q2))*j2 - j2.dot(q1)*jq2)/(3*M_PI*v); else { if(incBot) return (-16.*M_PI*mb*mb/v*j2.dot(q1)*jq2*A1(-q1,q2,mb)-16.*M_PI*mb*mb/v*j2*A2(-q1,q2,mb)) + (-16.*M_PI*mt*mt/v*j2.dot(q1)*jq2*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j2*A2(-q1,q2,mt)); else return (-16.*M_PI*mt*mt/v*j2.dot(q1)*jq2*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j2*A2(-q1,q2,mt)); } } CCurrent jHtop (CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector pin, bool helin, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { CCurrent j1 = j(pout,helout,pin,helin); CCurrent jq1(q1.e(),q1.px(),q1.py(),q1.pz()); if(mt == infinity) return ((q1.dot(q2))*j1 - j1.dot(q2)*jq1)/(3*M_PI*v); else { if(incBot) return (-16.*M_PI*mb*mb/v*j1.dot(q2)*jq1*A1(-q1,q2,mb)-16.*M_PI*mb*mb/v*j1*A2(-q1,q2,mb)) + (-16.*M_PI*mt*mt/v*j1.dot(q2)*jq1*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j1*A2(-q1,q2,mt)); else return (-16.*M_PI*mt*mt/v*j1.dot(q2)*jq1*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j1*A2(-q1,q2,mt)); } } CCurrent jioHtop (CLHEP::HepLorentzVector pin, bool helin, CLHEP::HepLorentzVector pout, bool helout, CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt, bool incBot, double mb) { CCurrent j1 = jio(pin,helin,pout,helout); CCurrent jq1(q1.e(),q1.px(),q1.py(),q1.pz()); if(mt == infinity) return ((q1.dot(q2))*j1 - j1.dot(q2)*jq1)/(3*M_PI*v); else { if(incBot) return (-16.*M_PI*mb*mb/v*j1.dot(q2)*jq1*A1(-q1,q2,mb)-16.*M_PI*mb*mb/v*j1*A2(-q1,q2,mb)) + (-16.*M_PI*mt*mt/v*j1.dot(q2)*jq1*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j1*A2(-q1,q2,mt)); else return (-16.*M_PI*mt*mt/v*j1.dot(q2)*jq1*A1(-q1,q2,mt)-16.*M_PI*mt*mt/v*j1*A2(-q1,q2,mt)); } } } // namespace anonymous double jM2unogqHQ (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // This construction is taking rapidity order: pg > p1out >> p2out // std::cerr<<"This Uno Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH1.m2()*qg.m2(); ampsq/=th; ampsq/=16.; ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. //Higgs coupling is included in Hjets.C return ampsq; } double jM2unogqbarHQ (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // This construction is taking rapidity order: pg > p1out >> p2out // std::cerr<<"This Uno Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH1.m2()*qg.m2(); ampsq/=th; ampsq/=16.; ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. //Higgs coupling is included in Hjets.C return ampsq; } double jM2unogqHQbar (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // This construction is taking rapidity order: pg > p1out >> p2out // std::cerr<<"This Uno Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH1.m2()*qg.m2(); ampsq/=th; ampsq/=16.; ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. //Higgs coupling is included in Hjets.C return ampsq; } double jM2unogqbarHQbar (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // This construction is taking rapidity order: pg > p1out >> p2out // std::cerr<<"This Uno Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH1.m2()*qg.m2(); ampsq/=th; ampsq/=16.; //Higgs coupling is included in Hjets.C ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. return ampsq; } double jM2unogqHg (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // This construction is taking rapidity order: pg > p1out >> p2out // std::cerr<<"This Uno Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH1.m2()*qg.m2(); ampsq/=th; ampsq/=16.; ampsq*=4./9.*4./9.; // Factor of (Cf/Ca) for each quark to match MH2qQ. // here we need 2 to match with the normalization // gq is 9./4. times the qQ //Higgs coupling is included in Hjets.C double ratio; // p2-/pb- in the notes // if (p2in.plus()>0) // if the gluon is the positive if (p2in.pz()>0) // if the gluon is the positive ratio=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio=p2out.minus()/p2in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; return ampsq*nonflipcolourmult*9./4.; //ca/cf = 9/4 } double jM2unogqbarHg (CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // This construction is taking rapidity order: pg > p1out >> p2out // std::cerr<<"This Uno Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH1.m2()*qg.m2(); ampsq/=th; ampsq/=16.; ampsq*=4./9.*4./9.; // Factor of (Cf/Ca) for each quark to match MH2qQ. // here we need 2 to match with the normalization // gq is 9./4. times the qQ //Higgs coupling is included in Hjets.C double ratio; // p2-/pb- in the notes // if (p2in.plus()>0) // if the gluon is the positive if (p2in.pz()>0) // if the gluon is the positive ratio=p2out.plus()/p2in.plus(); else // the gluon is the negative ratio=p2out.minus()/p2in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; return ampsq*nonflipcolourmult*9./4.; //ca/cf = 9/4 } double jM2unobqHQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // std::cout << "####################\n"; // std::cout << "# p1in : "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH2.m2()*q2.m2(); ampsq/=th; ampsq/=16.; ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. return ampsq; } double jM2unobqbarHQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { CLHEP::HepLorentzVector q1=p1in-p1out; // Top End CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); // Extra bit pre-gluon CLHEP::HepLorentzVector q3=-(p2in-p2out); // Bottom End // std::cerr<<"Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH2.m2()*q2.m2(); ampsq/=th; ampsq/=16.; ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. //Higgs coupling is included in Hjets.C return ampsq; } double jM2unobqHQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { CLHEP::HepLorentzVector q1=p1in-p1out; // Top End CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); // Extra bit pre-gluon CLHEP::HepLorentzVector q3=-(p2in-p2out); // Bottom End // std::cerr<<"Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH2.m2()*q2.m2(); ampsq/=th; ampsq/=16.; ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. //Higgs coupling is included in Hjets.C return ampsq; } double jM2unobqbarHQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { CLHEP::HepLorentzVector q1=p1in-p1out; // Top End CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); // Extra bit pre-gluon CLHEP::HepLorentzVector q3=-(p2in-p2out); // Bottom End // std::cerr<<"Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH2.m2()*q2.m2(); ampsq/=th; ampsq/=16.; ampsq*=4.*4./(9.*9.); // Factor of (Cf/Ca) for each quark to match MH2qQ. //Higgs coupling is included in Hjets.C return ampsq; } double jM2unobgHQg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { // std::cout << "####################\n"; // std::cout << "# p1in : "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH2.m2()*q2.m2(); ampsq/=th; ampsq/=16.; ampsq*=4./9.*4./9.; // Factor of (Cf/Ca) for each quark to match MH2qQ. // need twice to match the normalization //Higgs coupling is included in Hjets.C double ratio; // p2-/pb- in the notes // if (p2in.plus()>0) // if the gluon is the positive if (p1in.pz()>0) // if the gluon is the positive ratio=p1out.plus()/p1in.plus(); else // the gluon is the negative ratio=p1out.minus()/p1in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; return ampsq*nonflipcolourmult*9./4.; //ca/cf = 9/4 } double jM2unobgHQbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector pg, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector qH1, CLHEP::HepLorentzVector qH2, double mt, bool incBot, double mb) { CLHEP::HepLorentzVector q1=p1in-p1out; // Top End CLHEP::HepLorentzVector q2=-(p2in-p2out-pg); // Extra bit pre-gluon CLHEP::HepLorentzVector q3=-(p2in-p2out); // Bottom End // std::cerr<<"Current: "< 1.0000001) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) < 0.9999999) // std::cout << " Big Problem!! " << vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm) << " " << 2*vre(Lmm-U1mm,Lmm+U2mm) << std::endl; // Now add the t-channels for the Higgs double th=qH2.m2()*q2.m2(); ampsq/=th; ampsq/=16.; ampsq*=4./9.*4./9.; // Factor of (Cf/Ca) for each quark to match MH2qQ. //Higgs coupling is included in Hjets.C double ratio; // p2-/pb- in the notes // if (p2in.plus()>0) // if the gluon is the positive if (p1in.pz()>0) // if the gluon is the positive ratio=p1out.plus()/p1in.plus(); else // the gluon is the negative ratio=p1out.minus()/p1in.minus(); double nonflipcolourmult=(1.-1./9.)/2.*(ratio+1./ratio)+1./9.; return ampsq*nonflipcolourmult*9./4.; //ca/cf = 9/4 } // Begin finite mass stuff #ifdef RHEJ_BUILD_WITH_QCDLOOP namespace { // All the stuff needed for the box functions in qg->qgH now... //COM E1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM E1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2=-(k1+k2+kh); double Delta, Sigma, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; Sigma = 4.*s12*s34 - pow(S1+S2,2); return looprwfactor*(-s12*D0DD(k2, k1, q2, mq)*(1 - 8.*mq*mq/s12 + S2/(2.*s12) + S2*(s12 - 8.*mq*mq)*(s34 + S1)/(2.*s12*Delta) + 2.*(s34 + S1)*(s34 + S1)/Delta + S2*pow((s34 + S1),3)/Delta/Delta) - ((s12 + S2)*C0DD(k2, k1 + q2, mq) - s12*C0DD(k1, k2, mq) + (S1 - S2)*C0DD(k1 + k2, q2, mq) - S1*C0DD(k1, q2, mq))*(S2*(s12 - 4.*mq*mq)/(2.*s12*Delta) + 2.*(s34 + S1)/Delta + S2*pow((s34 + S1),2)/Delta/Delta) + (C0DD(k1, q2, mq) - C0DD(k1 + k2, q2, mq))*(1. - 4.*mq*mq/s12) - C0DD(k1 + k2, q2, mq)*2.*s34/ S1 - (B0DD(k1 + q2, mq) - B0DD(k1 + k2 + q2, mq))*2.*s34*(s34 + S1)/(S1*Delta) + (B0DD(q2, mq) - B0DD(k1 + k2 + q2, mq) + s12*C0DD(k1 + k2, q2, mq))*(2.*s34*(s34 + S1)*(S1 - S2)/(Delta*Sigma) + 2.*s34*(s34 + S1)/(S1*Delta)) + (B0DD(k1 + k2, mq) - B0DD(k1 + k2 + q2, mq) - (s34 + S1 + S2)*C0DD(k1 + k2, q2, mq))*2.*(s34 + S1)*(2.*s12*s34 - S2*(S1 + S2))/(Delta*Sigma)); } //COM F1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM F1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, Sigma, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; Sigma = 4.*s12*s34 - pow(S1+S2,2); return looprwfactor*(-S2*D0DD(k1, k2, q2, mq)*(0.5 - (s12 - 8.*mq*mq)*(s34 + S2)/(2.*Delta) - s12*pow((s34 + S2),3)/Delta/Delta) + ((s12 + S1)*C0DD(k1, k2 + q2, mq) - s12*C0DD(k1, k2, mq) - (S1 - S2)*C0DD(k1 + k2, q2, mq) - S2*C0DD(k2, q2, mq))*(S2*(s12 - 4.*mq*mq)/(2.*s12*Delta) + S2*pow((s34 + S2),2)/Delta/Delta) - (C0DD(k1 + k2, q2, mq) - C0DD(k1, k2 + q2, mq))*(1. - 4.*mq*mq/s12) - C0DD(k1, k2 + q2, mq) + (B0DD(k2 + q2, mq) - B0DD(k1 + k2 + q2, mq))*2.*pow((s34 + S2),2)/((s12 + S1)*Delta) - (B0DD( q2, mq) - B0DD(k1 + k2 + q2, mq) + s12*C0DD(k1 + k2, q2, mq))*2.*s34*(s34 + S2)*(S2 - S1)/(Delta*Sigma) + (B0DD( k1 + k2, mq) - B0DD(k1 + k2 + q2, mq) - (s34 + S1 + S2)*C0DD(k1 + k2, q2, mq))*2.*(s34 + S2)*(2.*s12*s34 - S2*(S1 + S2))/(Delta*Sigma)); } //COM G1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM G1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; return looprwfactor*(S2*D0DD(k1, q2, k2, mq)*(Delta/s12/s12 - 4.*mq*mq/s12) - S2*((s12 + S1)*C0DD(k1, k2 + q2, mq) - S1*C0DD(k1, q2, mq))*(1./ s12/s12 - (s12 - 4.*mq*mq)/(2.*s12*Delta)) - S2*((s12 + S2)*C0DD(k1 + q2, k2, mq) - S2*C0DD(k2, q2, mq))*(1./ s12/s12 + (s12 - 4.*mq*mq)/(2.*s12*Delta)) - C0DD(k1, q2, mq) - (C0DD(k1, k2 + q2, mq) - C0DD(k1, q2, mq))*4.*mq*mq/ s12 + (B0DD(k1 + q2, mq) - B0DD(k1 + k2 + q2, mq))*2./ s12 + (B0DD(k1 + q2, mq) - B0DD(q2, mq))*2.*s34/(s12*S1) + (B0DD(k2 + q2, mq) - B0DD(k1 + k2 + q2, mq))*2.*(s34 + S2)/(s12*(s12 + S1))); } //COM E4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM E4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, Sigma, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; Sigma = 4.*s12*s34 - pow(S1+S2,2); return looprwfactor* (-s12*D0DD(k2, k1, q2, mq)*(0.5 - (S1 - 8.*mq*mq)*(s34 + S1)/(2.*Delta) - s12*pow((s34 + S1),3)/Delta/Delta) + ((s12 + S2)*C0DD(k2, k1 + q2, mq) - s12*C0DD(k1, k2, mq) + (S1 - S2)*C0DD(k1 + k2, q2, mq) - S1*C0DD(k1, q2, mq))*((S1 - 4.*mq*mq)/(2.*Delta) + s12*pow((s34 + S1),2)/Delta/Delta) - C0DD(k1 + k2, q2, mq) + (B0DD(k1 + q2, mq) - B0DD(k1 + k2 + q2, mq))*(2.*s34/Delta + 2.*s12*(s34 + S1)/((s12 + S2)*Delta)) - (B0DD( q2, mq) - B0DD(k1 + k2 + q2, mq) + s12*C0DD(k1 + k2, q2, mq))*((2.*s34*(2.*s12*s34 - S2*(S1 + S2) + s12*(S1 - S2)))/(Delta*Sigma)) + (B0DD(k1 + k2, mq) - B0DD(k1 + k2 + q2, mq) - (s34 + S1 + S2)*C0DD(k1 + k2, q2, mq))*((2.*s12*(2.*s12*s34 - S1*(S1 + S2) + s34*(S2 - S1)))/(Delta*Sigma))); } //COM F4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM F4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, Sigma, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; Sigma = 4.*s12*s34 - pow(S1+S2,2); return looprwfactor* (-s12*D0DD(k1, k2, q2, mq)*(0.5 + (S1 - 8.*mq*mq)*(s34 + S2)/(2.*Delta) + s12*pow((s34 + S2),3)/Delta/Delta) - ((s12 + S1)*C0DD(k1, k2 + q2, mq) - s12*C0DD(k1, k2, mq) - (S1 - S2)*C0DD(k1 + k2, q2, mq) - S2*C0DD(k2, q2, mq))*((S1 - 4.*mq*mq)/(2.*Delta) + s12*pow((s34 + S2),2)/Delta/Delta) - C0DD(k1 + k2, q2, mq) - (B0DD(k2 + q2, mq) - B0DD(k1 + k2 + q2, mq))*2.*(s34 + S2)/Delta + (B0DD(q2, mq) - B0DD(k1 + k2 + q2, mq) + s12*C0DD(k1 + k2, q2, mq))*2.*s34*(2.*s12*s34 - S1*(S1 + S2) + s12*(S2 - S1))/(Delta*Sigma) - (B0DD(k1 + k2, mq) - B0DD(k1 + k2 + q2, mq) - (s34 + S1 + S2)*C0DD(k1 + k2, q2, mq))*(2.*s12*(2.*s12*s34 - S2*(S1 + S2) + s34*(S1 - S2))/(Delta*Sigma))); } //COM G4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM G4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; return looprwfactor* (-D0DD(k1, q2, k2, mq)*(Delta/s12 + (s12 + S1)/2. - 4.*mq*mq) + ((s12 + S1)*C0DD(k1, k2 + q2, mq) - S1*C0DD(k1, q2, mq))*(1./ s12 - (S1 - 4.*mq*mq)/(2.*Delta)) + ((s12 + S2)*C0DD( k1 + q2, k2, mq) - S2*C0DD(k2, q2, mq))*(1./ s12 + (S1 - 4.*mq*mq)/(2.*Delta)) + (B0DD( k1 + k2 + q2, mq) - B0DD(k1 + q2, mq))*2./(s12 + S2)); } //COM E10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM E10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, Sigma, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; Sigma = 4.*s12*s34 - pow(S1+S2,2); return looprwfactor*(-s12*D0DD(k2, k1, q2, mq)*((s34 + S1)/Delta + 12.*mq*mq*S1*(s34 + S1)/Delta/Delta - 4.*s12*S1*pow((s34 + S1),3)/Delta/Delta/Delta) - ((s12 + S2)*C0DD(k2, k1 + q2, mq) - s12*C0DD(k1, k2, mq) + (S1 - S2)*C0DD(k1 + k2, q2, mq) - S1*C0DD(k1, q2, mq))*(1./Delta + 4.*mq*mq*S1/Delta/Delta - 4.*s12*S1*pow((s34 + S1),2)/Delta/Delta/Delta) + C0DD(k1 + k2, q2, mq)*(4.*s12*s34*(S1 - S2)/(Delta*Sigma) - 4.*(s12 - 2.*mq*mq)*(2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma)) + (B0DD(k1 + q2, mq) - B0DD(k1 + k2 + q2, mq))*(4.*(s34 + S1)/((s12 + S2)*Delta) + 8.*S1*(s34 + S1)/Delta/Delta) + (B0DD(q2, mq) - B0DD(k1 + k2 + q2, mq) + s12*C0DD(k1 + k2, q2, mq))*(12.*s34*(2.*s12 + S1 + S2)*(2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma*Sigma) - 4.*s34*(4.*s12 + 3.*S1 + S2)/(Delta*Sigma) + 8.*s12*s34*(s34*(s12 + S2) - S1*(s34 + S1))/(Delta*Delta*Sigma)) + (B0DD(k1 + k2, mq) - B0DD(k1 + k2 + q2, mq) - (s34 + S1 + S2)*C0DD(k1 + k2, q2, mq))*(12.*s12*(2.*s34 + S1 + S2)*(2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma*Sigma) + 8.*s12*S1*(s34*(s12 + S2) - S1*(s34 + S1))/(Delta*Delta*Sigma))) + (COM(0.,1.)/(4.*M_PI*M_PI))*((2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma)); } //COM F10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM F10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, Sigma, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; Sigma = 4.*s12*s34 - pow(S1+S2,2); return looprwfactor* (s12*D0DD(k1, k2, q2, mq)*((s34 + S2)/Delta - 4.*mq*mq/Delta + 12.*mq*mq*s34*(s12 + S1)/Delta/Delta - 4.*s12*pow((s34 + S2),2)/Delta/Delta - 4.*s12*S1*pow((s34 + S2),3)/Delta/Delta/Delta) + ((s12 + S1)*C0DD(k1, k2 + q2, mq) - s12*C0DD(k1, k2, mq) - (S1 - S2)*C0DD(k1 + k2, q2, mq) - S2*C0DD(k2, q2, mq))*(1./Delta + 4.*mq*mq*S1/Delta/Delta - 4.*s12*(s34 + S2)/Delta/Delta - 4.*s12*S1*pow((s34 + S2),2)/Delta/Delta/Delta) - C0DD(k1 + k2, q2, mq)*(4.*s12*s34/(S2*Delta) + 4.*s12*s34*(S2 - S1)/(Delta*Sigma) + 4.*(s12 - 2.*mq*mq)*(2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma)) - (B0DD( k2 + q2, mq) - B0DD(k1 + k2 + q2, mq))*(4.*s34/(S2*Delta) + 8.*s34*(s12 + S1)/Delta/Delta) - (B0DD(q2, mq) - B0DD(k1 + k2 + q2, mq) + s12*C0DD(k1 + k2, q2, mq))*(-12*s34*(2*s12 + S1 + S2)*(2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma*Sigma) - 4.*s12*s34*s34/(S2*Delta*Delta) + 4.*s34*S1/(Delta*Sigma) - 4.*s34*(s12*s34*(2.*s12 + S2) - S1*S1*(2.*s12 + S1))/(Delta*Delta*Sigma)) - (B0DD(k1 + k2, mq) - B0DD(k1 + k2 + q2, mq) - (s34 + S1 + S2)*C0DD(k1 + k2, q2, mq))*(-12.*s12*(2.*s34 + S1 + S2)*(2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma*Sigma) + 8.*s12*(2.*s34 + S1)/(Delta*Sigma) - 8.*s12*s34*(2.*s12*s34 - S1*(S1 + S2) + s12*(S2 - S1))/(Delta*Delta*Sigma))) + (COM(0.,1.)/(4.*M_PI*M_PI))*((2.*s12*s34 - S1*(S1 + S2))/(Delta*Sigma)); } //COM G10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM G10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //CLHEP::HepLorentzVector q2=k3+k4; CLHEP::HepLorentzVector q2 = -(k1+k2+kh); double Delta, S1, S2, s12, s34; S1 = 2.*k1.dot(q2); S2 = 2.*k2.dot(q2); s12 = 2.*k1.dot(k2); //s34 = 2.*k3.dot(k4); s34 = q2.m2(); Delta = s12*s34 - S1*S2; return looprwfactor* (-D0DD(k1, q2, k2, mq)*(1. + 4.*S1*mq*mq/Delta) + ((s12 + S1)*C0DD(k1, k2 + q2, mq) - S1*C0DD(k1, q2, mq))*(1./Delta + 4.*S1*mq*mq/Delta/Delta) - ((s12 + S2)*C0DD(k1 + q2, k2, mq) - S2*C0DD(k2, q2, mq))*(1./Delta + 4.*S1*mq*mq/Delta/Delta) + (B0DD(k1 + k2 + q2, mq) - B0DD(k1 + q2, mq))*4.*(s34 + S1)/(Delta*(s12 + S2)) + (B0DD(q2, mq) - B0DD(k2 + q2, mq))*4.*s34/(Delta*S2)); } //COM H1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM H1(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //return E1(k1,k2,k3,k4,mq)+F1(k1,k2,k3,k4,mq)+G1(k1,k2,k3,k4,mq); return E1(k1,k2,kh,mq)+F1(k1,k2,kh,mq)+G1(k1,k2,kh,mq); } //COM H4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM H4(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //return E4(k1,k2,k3,k4,mq)+F4(k1,k2,k3,k4,mq)+G4(k1,k2,k3,k4,mq); return E4(k1,k2,kh,mq)+F4(k1,k2,kh,mq)+G4(k1,k2,kh,mq); } //COM H10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM H10(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //return E10(k1,k2,k3,k4,mq)+F10(k1,k2,k3,k4,mq)+G10(k1,k2,k3,k4,mq); return E10(k1,k2,kh,mq)+F10(k1,k2,kh,mq)+G10(k1,k2,kh,mq); } //COM H2(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM H2(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //return -1.*H1(k2,k1,k3,k4,mq); return -1.*H1(k2,k1,kh,mq); } //COM H5(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM H5(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //return -1.*H4(k2,k1,k3,k4,mq); return -1.*H4(k2,k1,kh,mq); } //COM H12(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector k3, CLHEP::HepLorentzVector k4, double mq) COM H12(CLHEP::HepLorentzVector k1, CLHEP::HepLorentzVector k2, CLHEP::HepLorentzVector kh, double mq) { //return -1.*H10(k2,k1,k3,k4,mq); return -1.*H10(k2,k1,kh,mq); } // FL and FT functions COM FL(CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mq) { CLHEP::HepLorentzVector Q = q1 + q2; double detQ2 = q1.m2()*q2.m2() - q1.dot(q2)*q1.dot(q2); return -1./(2.*detQ2)*((2.- 3.*q1.m2()*q2.dot(Q)/detQ2)*(B0DD(q1, mq) - B0DD(Q, mq)) + (2. - 3.*q2.m2()*q1.dot(Q)/detQ2)*(B0DD(q2, mq) - B0DD(Q, mq)) - (4.*mq*mq + q1.m2() + q2.m2() + Q.m2() - 3.*q1.m2()*q2.m2()*Q.m2()/detQ2)*C0DD( q1, q2, mq) - 2.); } COM FT(CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mq) { CLHEP::HepLorentzVector Q = q1 + q2; double detQ2 = q1.m2()*q2.m2() - q1.dot(q2)*q1.dot(q2); return -1./(2.*detQ2)*(Q.m2()*(B0DD(q1, mq) + B0DD(q2, mq) - 2.*B0DD(Q, mq) - 2.*q1.dot(q2)*C0DD(q1, q2, mq)) + (q1.m2() - q2.m2()) *(B0DD(q1, mq) - B0DD(q2, mq))) - q1.dot(q2)*FL(q1, q2, mq); } CLHEP::HepLorentzVector ParityFlip(CLHEP::HepLorentzVector p) { CLHEP::HepLorentzVector flippedVector; flippedVector.setE(p.e()); flippedVector.setX(-p.x()); flippedVector.setY(-p.y()); flippedVector.setZ(-p.z()); return flippedVector; } // HC amp for qg->qgH with finite top void g_gH_HC(CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH, double mq, current &retAns) { current cura1,pacur,p1cur,pHcur,conjeps1,conjepsH1,epsa,epsHa,epsHapart1,epsHapart2,conjepsH1part1,conjepsH1part2; current T1,T2,T3,T4,T5,T6,T7,T8,T9,T10, ans; COM ang1a,sqa1,aH1,Fta,Ft1,h4,h5,h10,h12; double prop; //cout << mq << endl; //double F = 4.*mq*mq/v/16./M_PI/M_PI; double F = 4.*mq*mq/v; //cout << mq << endl; //cout << HVE << endl; // Easier to have the whole thing as current object so I can use cdot functionality. // Means I need to write pa,p1 as current objects to_current(pa, pacur); to_current(p1,p1cur); to_current(pH,pHcur); bool gluonforward = true; if(pa.z() < 0) gluonforward = false; //HEJ gauge jio(pa,false,p1,false,cura1); if(gluonforward){ ang1a = sqrt(pa.plus()*p1.minus())*(p1.x()+COM(0.,1.)*p1.y())/p1.perp(); sqa1 = sqrt(pa.plus()*p1.minus())*(p1.x()-COM(0.,1.)*p1.y())/p1.perp(); } else { ang1a = sqrt(pa.minus()*p1.plus()); sqa1 = sqrt(pa.minus()*p1.plus()); } prop = (pa-p1-pH).m2(); //double Acheck = 1./(12.*M_PI*M_PI*v); cmult(-1./sqrt(2)/ang1a,cura1,conjeps1); cmult(1./sqrt(2)/sqa1,cura1,epsa); //if(mq<1000.){ Fta = FT(-pa,pa-pH,mq)/(pa-pH).m2(); Ft1 = FT(-p1-pH,p1,mq)/(p1+pH).m2(); //} //else{ // Fta = -Acheck/(pa-pH).m2()/F; // Ft1 = -Acheck/(p1+pH).m2()/F; //} //if(mq<1000.){ h4 = H4(p1,-pa,pH,mq); h5 = H5(p1,-pa,pH,mq); h10 = H10(p1,-pa,pH,mq); h12 = H12(p1,-pa,pH,mq); //} //else{ // h4 = COM(0.,2.)/16./M_PI/M_PI*Acheck/F; // h5 = COM(0.,-2.)/16./M_PI/M_PI*Acheck/F; // h10 = 0; // h12 = 0; //} cmult(Fta*pa.dot(pH),epsa,epsHapart1); cmult(-1.*Fta*cdot(pHcur,epsa),pacur,epsHapart2); cmult(Ft1*cdot(pHcur,conjeps1),p1cur,conjepsH1part1); cmult(-Ft1*p1.dot(pH),conjeps1,conjepsH1part2); cadd(epsHapart1,epsHapart2,epsHa); cadd(conjepsH1part1,conjepsH1part2,conjepsH1); aH1 = cdot(pHcur,cura1); if(gluonforward){ cmult(sqrt(2.)*sqrt(p1.plus()/pa.plus())*prop/sqa1,conjepsH1,T1); cmult(-sqrt(2.)*sqrt(pa.plus()/p1.plus())*prop/ang1a,epsHa,T2); } else{ cmult(-sqrt(2.)*sqrt(p1.minus()/pa.minus())*((p1.x()-COM(0.,1.)*p1.y())/p1.perp())*prop/sqa1,conjepsH1,T1); cmult(sqrt(2.)*sqrt(pa.minus()/p1.minus())*((p1.x()-COM(0.,1.)*p1.y())/p1.perp())*prop/ang1a,epsHa,T2); } cmult(sqrt(2.)/ang1a*aH1,epsHa,T3); cmult(sqrt(2.)/sqa1*aH1,conjepsH1,T4); cmult(-sqrt(2.)*Fta*pa.dot(p1)*aH1/sqa1,conjeps1,T5); cmult(-sqrt(2.)*Ft1*pa.dot(p1)*aH1/ang1a,epsa,T6); cmult(-aH1/sqrt(2.)/sqa1*h4*8.*COM(0.,1.)*M_PI*M_PI,conjeps1,T7); cmult(aH1/sqrt(2.)/ang1a*h5*8.*COM(0.,1.)*M_PI*M_PI,epsa,T8); cmult(aH1*aH1/2./ang1a/sqa1*h10*8.*COM(0.,1.)*M_PI*M_PI,pacur,T9); cmult(-aH1*aH1/2./ang1a/sqa1*h12*8.*COM(0.,1.)*M_PI*M_PI,p1cur,T10); for(int i=0;i<4;i++) { ans[i] = T1[i]+T2[i]+T3[i]+T4[i]+T5[i]+T6[i]+T7[i]+T8[i]+T9[i]+T10[i]; } retAns[0] = F/prop*ans[0]; retAns[1] = F/prop*ans[1]; retAns[2] = F/prop*ans[2]; retAns[3] = F/prop*ans[3]; } // HNC amp for qg->qgH with finite top void g_gH_HNC(CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH, double mq, current &retAns) { double prop; //COM F = 4.*mq*mq/v/16./M_PI/M_PI; double F = 4.*mq*mq/v; COM ang1a,Fta,Ft1,phase,aH1,oneHa,h1,h2,h4,h5,h10,h12,sqa1,Falpha,Fbeta; current ans,conjepsH1,epsHa,p1cur,pacur,pHcur,conjeps1,epsa,paplusp1cur,p1minuspacur,cur1a,cura1,epsHapart1,epsHapart2,conjepsH1part1,conjepsH1part2,T1,T2,T3,T4,T5a,T5b,T6,T7,T8a,T8b,T9,T10,T11a,T11b,T12a,T12b,T13; // Find here if pa, meaning the gluon, is forward or backward bool gluonforward = true; if(pa.z() < 0) gluonforward = false; jio(pa,true,p1,true,cura1); j(p1,true,pa,true,cur1a); to_current(pa,pacur); to_current(p1,p1cur); to_current(pH,pHcur); to_current(pa+p1,paplusp1cur); to_current(p1-pa,p1minuspacur); aH1 = cdot(pHcur,cura1); oneHa = cdot(pHcur,cur1a); if(gluonforward){ ang1a = sqrt(pa.plus()*p1.minus())*(p1.x()+COM(0.,1.)*p1.y())/p1.perp(); sqa1 = sqrt(pa.plus()*p1.minus())*(p1.x()-COM(0.,1.)*p1.y())/p1.perp(); } else { ang1a = sqrt(pa.minus()*p1.plus()); sqa1 = sqrt(pa.minus()*p1.plus()); } prop = (pa-p1-pH).m2(); cmult(1./sqrt(2)/sqa1,cur1a,epsa); cmult(-1./sqrt(2)/sqa1,cura1,conjeps1); phase = cdot(conjeps1,epsa); Fta = FT(-pa,pa-pH,mq)/(pa-pH).m2(); Ft1 = FT(-p1-pH,p1,mq)/(p1+pH).m2(); Falpha = FT(p1-pa,pa-p1-pH,mq); Fbeta = FL(p1-pa,pa-p1-pH,mq); h1 = H1(p1,-pa,pH,mq); h2 = H2(p1,-pa,pH,mq); h4 = H4(p1,-pa,pH,mq); h5 = H5(p1,-pa,pH,mq); h10 = H10(p1,-pa,pH,mq); h12 = H12(p1,-pa,pH,mq); cmult(Fta*pa.dot(pH),epsa,epsHapart1); cmult(-1.*Fta*cdot(pHcur,epsa),pacur,epsHapart2); cmult(Ft1*cdot(pHcur,conjeps1),p1cur,conjepsH1part1); cmult(-Ft1*p1.dot(pH),conjeps1,conjepsH1part2); cadd(epsHapart1,epsHapart2,epsHa); cadd(conjepsH1part1,conjepsH1part2,conjepsH1); if(gluonforward){ cmult(sqrt(2.)*sqrt(p1.plus()/pa.plus())*prop/sqa1,conjepsH1,T1); cmult(-sqrt(2.)*sqrt(pa.plus()/p1.plus())*prop/sqa1,epsHa,T2); } else{ cmult(-sqrt(2.)*sqrt(p1.minus()/pa.minus())*((p1.x()-COM(0.,1.)*p1.y())/p1.perp())*prop/sqa1,conjepsH1,T1); cmult(sqrt(2.)*sqrt(pa.minus()/p1.minus())*((p1.x()+COM(0.,1.)*p1.y())/p1.perp())*prop/sqa1,epsHa,T2); } COM boxdiagFact = 8.*COM(0.,1.)*M_PI*M_PI; cmult(aH1*sqrt(2.)/sqa1,epsHa,T3); cmult(oneHa*sqrt(2.)/sqa1,conjepsH1,T4); cmult(-2.*phase*Fta*pa.dot(pH),p1cur,T5a); cmult(2.*phase*Ft1*p1.dot(pH),pacur,T5b); cmult(-sqrt(2.)*Fta*p1.dot(pa)*oneHa/sqa1,conjeps1,T6); cmult(-sqrt(2.)*Ft1*pa.dot(p1)*aH1/sqa1,epsa,T7); cmult(-boxdiagFact*phase*h2,pacur,T8a); cmult(boxdiagFact*phase*h1,p1cur,T8b); cmult(boxdiagFact*aH1/sqrt(2.)/sqa1*h5,epsa,T9); cmult(-boxdiagFact*oneHa/sqrt(2.)/sqa1*h4,conjeps1,T10); cmult(boxdiagFact*aH1*oneHa/2./sqa1/sqa1*h10,pacur,T11a); cmult(-boxdiagFact*aH1*oneHa/2./sqa1/sqa1*h12,p1cur,T11b); cmult(-phase/(pa-p1).m2()*Falpha*(p1-pa).dot(pa-p1-pH),paplusp1cur,T12a); cmult(phase/(pa-p1).m2()*Falpha*(pa+p1).dot(pa-p1-pH),p1minuspacur,T12b); cmult(-phase*Fbeta*(pa-p1-pH).m2(),paplusp1cur,T13); //cout << phase << endl; for(int i=0;i<4;i++) { ans[i] = T1[i]+T2[i]+T3[i]+T4[i]+T5a[i]+T5b[i]+T6[i]+T7[i]+T8a[i]+T8b[i]+T9[i]+T10[i]+T11a[i]+T11b[i]+T12a[i]+T12b[i]+T13[i]; } retAns[0] = F/prop*ans[0]; retAns[1] = F/prop*ans[1]; retAns[2] = F/prop*ans[2]; retAns[3] = F/prop*ans[3]; } } // namespace anonymous // JDC - new amplitude with Higgs emitted close to gluon with full mt effects. Keep usual HEJ-style function call double MH2gq_outsideH(CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in, CLHEP::HepLorentzVector pH, double mq, bool includeBottom, double mq2) { current cur2bplus,cur2bminus, cur2bplusFlip, cur2bminusFlip; current retAns,retAnsb; j(p2out,true,p2in,true,cur2bplus); j(p2out,false,p2in,false,cur2bminus); j(ParityFlip(p2out),true,ParityFlip(p2in),true,cur2bplusFlip); j(ParityFlip(p2out),false,ParityFlip(p2in),false,cur2bminusFlip); COM app1,app2,apm1,apm2; COM app3, app4, apm3, apm4; if(!includeBottom) { g_gH_HC(p1in,p1out,pH,mq,retAns); app1=cdot(retAns,cur2bplus); app2=cdot(retAns,cur2bminus); g_gH_HC(ParityFlip(p1in),ParityFlip(p1out),ParityFlip(pH),mq,retAns); app3=cdot(retAns,cur2bplusFlip); app4=cdot(retAns,cur2bminusFlip); // And non-conserving bits g_gH_HNC(p1in,p1out,pH,mq,retAns); apm1=cdot(retAns,cur2bplus); apm2=cdot(retAns,cur2bminus); g_gH_HNC(ParityFlip(p1in),ParityFlip(p1out),ParityFlip(pH),mq,retAns); apm3=cdot(retAns,cur2bplusFlip); apm4=cdot(retAns,cur2bminusFlip); } else { g_gH_HC(p1in,p1out,pH,mq,retAns); g_gH_HC(p1in,p1out,pH,mq2,retAnsb); app1=cdot(retAns,cur2bplus) + cdot(retAnsb,cur2bplus); app2=cdot(retAns,cur2bminus) + cdot(retAnsb,cur2bminus); g_gH_HC(ParityFlip(p1in),ParityFlip(p1out),ParityFlip(pH),mq,retAns); g_gH_HC(ParityFlip(p1in),ParityFlip(p1out),ParityFlip(pH),mq2,retAnsb); app3=cdot(retAns,cur2bplusFlip) + cdot(retAnsb,cur2bplusFlip); app4=cdot(retAns,cur2bminusFlip) + cdot(retAnsb,cur2bminusFlip); // And non-conserving bits g_gH_HNC(p1in,p1out,pH,mq,retAns); g_gH_HNC(p1in,p1out,pH,mq2,retAnsb); apm1=cdot(retAns,cur2bplus) + cdot(retAnsb,cur2bplus); apm2=cdot(retAns,cur2bminus) + cdot(retAnsb,cur2bminus); g_gH_HNC(ParityFlip(p1in),ParityFlip(p1out),ParityFlip(pH),mq,retAns); g_gH_HNC(ParityFlip(p1in),ParityFlip(p1out),ParityFlip(pH),mq2,retAnsb); apm3=cdot(retAns,cur2bplusFlip) + cdot(retAnsb,cur2bplusFlip); apm4=cdot(retAns,cur2bminusFlip) + cdot(retAnsb,cur2bminusFlip); } return (abs2(app1) + abs2(app2) + abs2(app3) + abs2(app4) + abs2(apm1) + abs2(apm2) + abs2(apm3) + abs2(apm4))*12./4./(3.*8.); //return (abs2(app1))*12./(3.*8.); // factor = 12 (colour sum) /4 (hel avg) /(3*8) (col avg) } #endif // RHEJ_BUILD_WITH_QCDLOOP double C2gHgm(CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH) { static double A=1./(3.*M_PI*v); // Implements Eq. (4.22) in hep-ph/0301013 with modifications to incoming plus momenta double s12,p1p,p2p; COM p1perp,p3perp,phperp; // Determine first whether this is the case p1p\sim php>>p3p og the opposite s12=p1.invariantMass2(-p2); if (p2.pz()>0.) { // case considered in hep-ph/0301013 p1p=p1.plus(); p2p=p2.plus(); } else { // opposite case p1p=p1.minus(); p2p=p2.minus(); } p1perp=p1.px()+COM(0,1)*p1.py(); phperp=pH.px()+COM(0,1)*pH.py(); p3perp=-(p1perp+phperp); COM temp=COM(0,1)*A/(2.*s12)*(p2p/p1p*conj(p1perp)*p3perp+p1p/p2p*p1perp*conj(p3perp)); temp=temp*conj(temp); return temp.real(); } double C2gHgp(CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH) { static double A=1./(3.*M_PI*v); // Implements Eq. (4.23) in hep-ph/0301013 double s12,php,p1p,phm; COM p1perp,p3perp,phperp; // Determine first whether this is the case p1p\sim php>>p3p og the opposite s12=p1.invariantMass2(-p2); if (p2.pz()>0.) { // case considered in hep-ph/0301013 php=pH.plus(); phm=pH.minus(); p1p=p1.plus(); } else { // opposite case php=pH.minus(); phm=pH.plus(); p1p=p1.minus(); } p1perp=p1.px()+COM(0,1)*p1.py(); phperp=pH.px()+COM(0,1)*pH.py(); p3perp=-(p1perp+phperp); COM temp=-COM(0,1)*A/(2.*s12)*(conj(p1perp*p3perp)*pow(php/p1p,2)/(1.+php/p1p)+s12*(pow(conj(phperp),2)/(pow(abs(phperp),2)+p1p*phm)-pow(conj(p3perp)+(1.+php/p1p)*conj(p1perp),2)/((1.+php/p1p)*(pH.m2()+2.*p1.dot(pH))))); temp=temp*conj(temp); return temp.real(); } double C2qHqm(CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH) { static double A=1./(3.*M_PI*v); // Implements Eq. (4.22) in hep-ph/0301013 double s12,p2p,p1p; COM p1perp,p3perp,phperp; // Determine first whether this is the case p1p\sim php>>p3p og the opposite s12=p1.invariantMass2(-p2); if (p2.pz()>0.) { // case considered in hep-ph/0301013 p2p=p2.plus(); p1p=p1.plus(); } else { // opposite case p2p=p2.minus(); p1p=p1.minus(); } p1perp=p1.px()+COM(0,1)*p1.py(); phperp=pH.px()+COM(0,1)*pH.py(); p3perp=-(p1perp+phperp); COM temp=A/(2.*s12)*(sqrt(p2p/p1p)*p3perp*conj(p1perp)+sqrt(p1p/p2p)*p1perp*conj(p3perp)); temp=temp*conj(temp); return temp.real(); }