Page MenuHomeHEPForge

No OneTemporary

diff --git a/include/HEJ/FKS.hh b/include/HEJ/FKS.hh
index a63e2b2..c1cde8a 100644
--- a/include/HEJ/FKS.hh
+++ b/include/HEJ/FKS.hh
@@ -1,287 +1,288 @@
/** \file
* \brief Contains functions for FKS implementation
*
* \authors The HEJ collaboration (see AUTHORS for details)
* \date 2019-2020
* \copyright GPLv2 or later
*/
#pragma once
#include <functional>
#include <vector>
#include "fastjet/PseudoJet.hh"
#include "HEJ/Config.hh"
#include "HEJ/PDG_codes.hh"
#include "HEJ/Parameters.hh"
#include "CLHEP/Vector/LorentzVector.h"
#include "HEJ/Config.hh"
namespace HEJ {
namespace FKS {
//! Main FKS implementation for exact qQ->qQ(g) at NLO
/**
* @param ev Event
* @param FKSParams Struct of all FKS parameters
* @returns BVI if 2 partons in final state, RS if 3 partons in final state
*/
double ME2_NLO_FKS(Event const & ev, FKSConfig const & FKSParams);
///// Exact squared amplitudes - required for validating FKS NLO implementation. /////
//! Square of 0->qb Qb q Q amplitude. No flux or averaging factors
/**
* @param pqb Momentum of outgoing anti-quark, flavour q
* @param pQb Momentum of outgoing anti-quark, flavour Q
* @param pq Momentum of outgoing quark, flavour q
* @param pQ Momentum of outgoing quark, flavour Q
* @returns Square of the helicity-summed 0->qb Qb q Q amplitude
*/
double M2_qb_Qb_q_Q(
CLHEP::HepLorentzVector const & pqb,
CLHEP::HepLorentzVector const & pQb,
CLHEP::HepLorentzVector const & pq,
CLHEP::HepLorentzVector const & pQ
);
//! Square of 0->q qb g1 g2 amplitude. No flux or averaging factors
/**
* @param pg1 Momentum of outgoing gluon 1
* @param pqb Momentum of outgoing anti-quark
* @param pg2 Momentum of outgoing gluon 2
* @param pq Momentum of outgoing quark
* @returns Square of the helicity-summed 0->q qb g1 g2 amplitude
*/
double M2_g1_qb_g2_q(
CLHEP::HepLorentzVector const & pg1,
CLHEP::HepLorentzVector const & pqb,
CLHEP::HepLorentzVector const & pg2,
CLHEP::HepLorentzVector const & pq
);
//! Square of 0->qb Qb q Q g amplitude. No flux or averaging factors
/**
* @param pqb Momentum of outgoing anti-quark, flavour q
* @param pQb Momentum of outgoing anti-quark, flavour Q
* @param pq Momentum of outgoing quark, flavour q
* @param pQ Momentum of outgoing quark, flavour Q
* @param pg Momentum of outgoing gluon
* @returns Square of the helicity-summed 0->qb Qb q Q g amplitude
*/
double M2_qb_Qb_q_Q_g(
CLHEP::HepLorentzVector const & pqb,
CLHEP::HepLorentzVector const & pQb,
CLHEP::HepLorentzVector const & pq,
CLHEP::HepLorentzVector const & pQ,
CLHEP::HepLorentzVector const & pg
);
//! Matrix element for q Q -> q Q, including flux and averaging factors
/**
* @param pqin Momentum of incoming quark, flavour q
* @param qQin Momentum of incoming quark, flavour Q
* @param pqout Momentum of outgoing quark, flavour q
* @param pQout Momentum of outgoing quark, flavour Q
* @returns Matrix element for q Q -> q Q, including flux and averaging factors
*/
double M_q_Q_to_q_Q(
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pQin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pQout
);
//! Matrix element for q g -> q g, including flux and averaging factors
/**
* @param pqin Momentum of incoming quark
* @param pgin Momentum of incoming gluon
* @param pqout Momentum of outgoing quark
* @param pgout Momentum of outgoing gluon
* @returns Matrix element for q Q -> q Q, including flux and averaging factors
*/
double M_q_g_to_q_g(
CLHEP::HepLorentzVector const & pg1,
CLHEP::HepLorentzVector const & pqb,
CLHEP::HepLorentzVector const & pg2,
CLHEP::HepLorentzVector const & pq
);
//! Matrix element for q Q -> q Q g, including flux and averaging factors
/**
* @param pqin Momentum of incoming quark, flavour q
* @param qQin Momentum of incoming quark, flavour Q
* @param pqout Momentum of outgoing quark, flavour q
* @param pQout Momentum of outgoing quark, flavour Q
* @param pgout Momentum of outgoing gluon
* @returns Matrix element for q Q -> q Q g, including flux and averaging factors
*/
double M_q_Q_to_q_Q_g(
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pQin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pQout,
CLHEP::HepLorentzVector const & pgout
);
///// 2-parton functions/////
double Regulated_2parton_q_Q_to_q_Q(
double const mur2,
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kq,
CLHEP::HepLorentzVector const & kQ
);
double Q_q(
FKSConfig const & FKSParams,
double sqrtS,
double Eq
);
double Q_g(
FKSConfig const & FKSParams,
double sqrtS,
double Eg
);
//Implement (5.6) of FKS
double Q_q_Q_to_q_Q(
double mur2,
FKSConfig const & FKSParams,
double sqrtS,
double Eq,
double EQ
);
double Regulated_Virtuals_q_Q_to_q_Q(
double mu2,
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pQin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pQout
);
double Regulated_Integrated_Eikonal_mn(
FKSConfig const & FKSParams,
double Shat,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kn
);
double dip(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & ki
);
double dim(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & ki
);
double dij(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & ki,
CLHEP::HepLorentzVector const & kj
);
//! FKS regulated matrix element for region Sip.
/**
* @param FKSParams FKS parameters specified in runcard.
* @returns Regulated ME for qQ -> qQg where parton i can be soft or collinear to parton kp
*/
- double Mip_q_Q_to_q_Q_g(
+ double Mib_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kq,
CLHEP::HepLorentzVector const & kQ,
CLHEP::HepLorentzVector const & kg,
- std::string flavour_i
+ std::string flavour_i,
+ std::string beam
);
//! FKS regulated matrix element for region Sij.
/**
* @param FKSParams FKS parameters specified in runcard.
* @param K_p_m_to_q_Q_g Vector of original event momenta, {kp,km,k1,k2,k3}
* @param i The outgoing parton which can be soft/collinear to j (0=q,1=Q,2=g)
* @param j The FKS partner of parton i (0=q,1=Q,2=g)
* @returns Regulated ME for qQ -> qQg where parton i can be soft or collinear to parton j
*/
double Mgj_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kq,
CLHEP::HepLorentzVector const & kQ,
CLHEP::HepLorentzVector const & kg,
std::string flavour_j
);
std::vector <CLHEP::HepLorentzVector> counter_event_ISC(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & ki,
CLHEP::HepLorentzVector const & kj,
CLHEP::HepLorentzVector const & kk,
std::string type
);
void counter_event_FSC(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector & kib,
CLHEP::HepLorentzVector & kjb,
CLHEP::HepLorentzVector & kkb,
CLHEP::HepLorentzVector const & ki,
CLHEP::HepLorentzVector const & kj,
CLHEP::HepLorentzVector const & kk,
std::string type
);
std::vector <double> khat(
const double zeta_j,
const double CosPhi_j,
const double SinPhi_j,
const double zeta_ij,
const double CosPhi_ij,
const double SinPhi_ij
);
double Ggp_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kq,
CLHEP::HepLorentzVector const & kQ,
const double zeta_g,
const double mur2
);
double Gqp_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
const double zeta_q,
CLHEP::HepLorentzVector const & kQ,
CLHEP::HepLorentzVector const & kg,
const double mur2
);
std::vector <CLHEP::HepLorentzVector> SplitMassive(
CLHEP::HepLorentzVector P,
CLHEP::HepLorentzVector p1,
CLHEP::HepLorentzVector p2
);
} // namespace FKS
} //namespace HEJ
\ No newline at end of file
diff --git a/src/FKS.cc b/src/FKS.cc
index 7c6587c..1a86541 100644
--- a/src/FKS.cc
+++ b/src/FKS.cc
@@ -1,1113 +1,1130 @@
/**
* \authors The HEJ collaboration (see AUTHORS for details)
* \date 2019-2022
* \copyright GPLv2 or later
*/
#include "HEJ/FKS.hh"
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstdlib>
#include <iterator>
#include <limits>
#include <unordered_map>
#include <utility>
#include <gsl/gsl_sf_dilog.h> //Dilog for FKS implementation
#include "fastjet/PseudoJet.hh"
#include "HEJ/ConfigFlags.hh"
#include "HEJ/Constants.hh"
#include "HEJ/Event.hh"
#include "HEJ/LorentzVector.hh"
#include "HEJ/PDG_codes.hh"
#include "HEJ/Particle.hh"
#include "HEJ/event_types.hh"
#include "HEJ/exceptions.hh"
#include "HEJ/utility.hh"
#include "HEJ/jets.hh"
#include "HEJ/Config.hh"
#include "HEJ/MatrixElement.hh"
namespace HEJ {
namespace FKS {
//////// FKS functions /////////
//Shorthand for paper references:
//FKS: arXiv:hep-ph/9512328
//ES: DOI 10.1016/0550-3213(86)90232-4
//MadFKS: 0908.4272
double ME2_NLO_FKS(Event const & ev, FKSConfig const & FKSParams) {
//Read all partons from event
auto const & incoming = ev.incoming();
auto const out_partons = filter_partons(ev.outgoing());
//HEJ labelling of incoming partons: pa has negative z component
const auto pa = to_HepLorentzVector(incoming[0]);
const auto pb = to_HepLorentzVector(incoming[1]);
//Calculate boost to partonic COM frame
const double Ea= pa.e();
const double Eb= pb.e();
double beta_to_COM = (1-(Eb/Ea))/(1+(Eb/Ea));
//Switch to FKS labelling of partons
CLHEP::HepLorentzVector kp=pb;
CLHEP::HepLorentzVector km=pa;
//Perform boost for incoming partons
kp.boostZ(beta_to_COM);
km.boostZ(beta_to_COM);
//For now, use central renormalisation scale
const double mur2 = pow(ev.central().mur,2);
//Temporarily require u(kp) d(km) incoming
if(!(incoming[0].type==1&&incoming[1].type==2)){
throw std::logic_error("FKS treatment currently requires u(kp) d(km) incoming.");
}
if(out_partons.size()==2){
//HEJ labelling of outgoing partons: y1<y2, f1=fa, f2=fb.
//Caution: .front() refers to position in list, ordered from lowest to highest rapidity.
const auto p1 = to_HepLorentzVector(out_partons.front());
const auto p2 = to_HepLorentzVector(out_partons.back());
//Temporarily require u(p2) d(p1) outgoing, i.e. FKL initial event.
if(!(out_partons.front().type==1&&out_partons.back().type==2)){
throw std::logic_error("FKS treatment currently requires u(kp) d(km) incoming.");
}
//Change to FKS labelling of partons
//Temporarily q=u=2, Q=d=1
CLHEP::HepLorentzVector kq=p2;
CLHEP::HepLorentzVector kQ=p1;
//Boost along z direction to partonic COM frame
kq.boostZ(beta_to_COM);
kQ.boostZ(beta_to_COM);
//Return C+S+V in (4.3) of MadFKS
//But factor out (as/2/p2)gs^4
//Q: does d\sigma^V include running coupling?
//return M_q_Q_to_q_Q(kp,km,kq,kQ);
return Regulated_2parton_q_Q_to_q_Q(mur2, FKSParams, kp, km, kq, kQ);
} else if(out_partons.size()==3){
//Define the momenta based on event classification.
CLHEP::HepLorentzVector pq;
CLHEP::HepLorentzVector pQ;
CLHEP::HepLorentzVector pg;
if (ev.type()==event_type::FKL){
pQ = to_HepLorentzVector(out_partons.at(0));
pg = to_HepLorentzVector(out_partons.at(1));
pq = to_HepLorentzVector(out_partons.at(2));
} else if (ev.type()==event_type::unordered_backward){
//std::cout<<"unob"<<std::endl;
pg = to_HepLorentzVector(out_partons.at(0));
pQ = to_HepLorentzVector(out_partons.at(1));
pq = to_HepLorentzVector(out_partons.at(2));
} else if (ev.type()==event_type::unordered_forward){
//std::cout<<"unof"<<std::endl;
pQ = to_HepLorentzVector(out_partons.at(0));
pq = to_HepLorentzVector(out_partons.at(1));
pg = to_HepLorentzVector(out_partons.at(2));
} else {
throw std::logic_error("Invalid event type.");
}
//ki = pi in partonic COM frame.
CLHEP::HepLorentzVector kq=pq;
CLHEP::HepLorentzVector kQ=pQ;
CLHEP::HepLorentzVector kg=pg;
kq.boostZ(beta_to_COM);
kQ.boostZ(beta_to_COM);
kg.boostZ(beta_to_COM);
//Arbitrary factor to dominate Born, useful until we implement correct couplings etc.
const double arbitrary_f = 10000.0;
//Check if any partons are 'exactly' collinear
double lambda = FKSParams.lambda_FKS;
if (kg.perp()<lambda){
double zeta_g = kg.z()/kp.z();
if (zeta_g>0){
return arbitrary_f*Ggp_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, zeta_g, mur2);
} else {
return arbitrary_f*Ggp_q_Q_to_q_Q_g(FKSParams, km, kp, kQ, kq, -zeta_g, mur2);
} // Q: Yields equal contribution, not ~2/3 as I expected.
} else if (kq.perp()<lambda) {
double z = kq.z()/kp.z();
if (z>0){
return arbitrary_f*Gqp_q_Q_to_q_Q_g(FKSParams, kp, km, z, kQ, kg, mur2);
} else {
throw std::logic_error("Outgoing u currently forbidden along - beam.");
}
} else if (kQ.perp()<lambda) {
double z = kQ.z()/kp.z();
if (z<0){
return arbitrary_f*Gqp_q_Q_to_q_Q_g(FKSParams, km, kp, -z, kq, kg, mur2);
} else {
throw std::logic_error("Outgoing d currently forbidden along + beam.");
}
}
//Measurement functions for (pb + pa -> pq + pQ + pg )
// (2.67) and (2.68) of 0709.2092, expressed in terms of invariants.
const double dgp = dip(FKSParams, pb, pa, pg);
const double dqp = dip(FKSParams, pb, pa, pq);
const double dQp = dip(FKSParams, pb, pa, pQ);
- const double dgm = dim(FKSParams, pb, pa, pg);
- const double dqm = dim(FKSParams, pb, pa, pq);
- const double dQm = dim(FKSParams, pb, pa, pQ);
+ const double dgm = dim(FKSParams, pa, pb, pg);
+ const double dqm = dim(FKSParams, pa, pb, pq);
+ const double dQm = dim(FKSParams, pa, pb, pQ);
const double dgq = dij(FKSParams, pb, pa, pg, pq);
const double dgQ = dij(FKSParams, pb, pa, pg, pQ);
const double Denom = (1/dgp+1/dqp+1/dQp+1/dgm+1/dqm+1/dQm+1/dgq+1/dgQ);
const double Sgp = 1./(Denom*dgp);
const double Sqp = 1./(Denom*dqp);
const double SQp = 1./(Denom*dQp);
const double Sgm = 1./(Denom*dgm);
const double Sqm = 1./(Denom*dqm);
const double SQm = 1./(Denom*dQm);
const double Sgq = 1./(Denom*dgq);
const double SgQ = 1./(Denom*dgQ);
double ME2_3parton= 0.;
- //Sum FSC contributions
- ME2_3parton += Sgp*Mip_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "g");
- //ME2_3parton += Sqp*Mip_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "q");
- //ME2_3parton += SQp*Mip_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "Q");
+ //Sum ISC contributions
+ ME2_3parton += Sgp*Mib_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "g", "p");
+ ME2_3parton += Sqp*Mib_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "q", "p");
+ ME2_3parton += SQp*Mib_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "Q", "p");
- // Q: Nice way to implement im case without redundancy?
+ ME2_3parton += Sgm*Mib_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "g", "m");
+ ME2_3parton += Sqm*Mib_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "q", "m");
+ ME2_3parton += SQm*Mib_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "Q", "m");
+
+ //Todo: FSC contributions
//ME2_3parton += Sgq*Mgj_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "q");
//ME2_3parton += SgQ*Mgj_q_Q_to_q_Q_g(FKSParams, kp, km, kq, kQ, kg, "Q");
- //std::cout<<"Mgp="<<ME2_3parton<<std::endl;
return arbitrary_f*ME2_3parton;
} else {
throw std::logic_error("FKS treatment currently supports only 2 or 3 partons in final state.");
}
}
///// Exact squared amplitudes - required for validating FKS NLO implementation. /////
//Square of 0->qb Qb q Q amplitude. No flux or averaging factors. C.f. table 2 of ES.
double M2_qb_Qb_q_Q(
CLHEP::HepLorentzVector const & pqb,
CLHEP::HepLorentzVector const & pQb,
CLHEP::HepLorentzVector const & pq,
CLHEP::HepLorentzVector const & pQ
){
const double sqQ= 2.*pq.dot(pQ);
const double sqqb= -2.*pq.dot(pqb);
const double sqQb= -2.*pq.dot(pQb);
const double kin = 2.*(sqQ*sqQ+sqQb*sqQb)/(sqqb*sqqb);
const double col = N_C*N_C-1.;
return col*kin;
}
//Square of 0->g1 qb g2 q amplitude. No flux or averaging factors. C.f. table 2 of ES.
//Implicit TR=1/2.
double M2_g1_qb_g2_q(
CLHEP::HepLorentzVector const & pg1,
CLHEP::HepLorentzVector const & pqb,
CLHEP::HepLorentzVector const & pg2,
CLHEP::HepLorentzVector const & pq
){
const double sqg1= 2.*pq.dot(pg1);
const double sqg2= 2.*pq.dot(pg1);
const double sqbg1= 2.*pqb.dot(pg2);
const double sqbg2= 2.*pqb.dot(pg2);
const double sqqb= 2.*pq.dot(pqb);
const double kin0 = (sqg1*sqg1+sqg2*sqg2+sqbg1*sqbg1+sqbg2*sqbg2)/2.;
const double col0 = 2.*(N_C*N_C-1.)/N_C;
const double f1 = (N_C-1.)/(sqg1*sqg2);
const double f2 = 2.*N_C*N_C/(sqqb*sqqb);
return col0*kin0*(f1+f2);
}
//Implements (3.4) of ES.
//Converted to all-outgoing convention, eps->0 limit taken,
//and reorganised kinematics into IR stable form.
double M2_qb_Qb_q_Q_g(
CLHEP::HepLorentzVector const & pqb,
CLHEP::HepLorentzVector const & pQb,
CLHEP::HepLorentzVector const & pq,
CLHEP::HepLorentzVector const & pQ,
CLHEP::HepLorentzVector const & pg
){
//Overcomplete set of invariants, but allows compact numerator:
const double sqbQb= 2.*pqb.dot(pQb); //s
const double sqQ= 2.*pq.dot(pQ); //s'
const double sqbq= 2.*pqb.dot(pq); //t
const double sQbQ= 2.*pQb.dot(pQ); //t'
const double sqbQ= 2.*pqb.dot(pQ); //u
const double sQbq= 2.*pQb.dot(pq); //u'
const double kin0 = (sqbQ*sqbQ + sqbQb*sqbQb + sqQ*sqQ + sQbq*sQbq)/2.;
/*
//Old form of kinematics, numerically unstable in soft limit.
double kin1 = ((s14 + s23)*(-s14*s23 + s13*s24 + s12*s34) + s23*(s12*s24 + s13*s34) + s14*(s12*s13 + s24*s34))/4.;
double kin2 = (2.*s13*(s14 + s23)*s24 + 2.*s14*s23*(s13 + s24) + (s12 + s34)*(-s14*s23 - s13*s24 + s12*s34))/4.;
*/
//We need pairs of the following invariants to obtain IR-convergent numerator:
const double sqbg= 2.*pqb.dot(pg);
const double sQbg= 2.*pQb.dot(pg);
const double sqg= 2.*pq.dot(pg);
const double sQg= 2.*pQ.dot(pg);
const double kin1s = (1/4.)*(sqbQ*(sQbg*sqg + sqbg*sQg)-sqbg*sQg*(sQbg + sqg));
const double kin2s = (1/4.)*(sqbQ*(sQbg*sqg + sqbg*sQg) + sqbg*(sQbg*sqg + sQbg*sQg - 2.*sqg*sQg)
-2.*sqbQb*(sqbg*sQbg + sqg*sQg) + (sqbg*sqg + sQbg*sQg)*sqbq);
const double col1 = (N_C*N_C-1.)*(N_C*N_C-1.)/N_C;
const double col2 = (N_C*N_C-1.)/N_C;
return 16.*kin0*(col1*kin1s-col2*kin2s)/(sqbq*sQbQ*sqbg*sQbg*sqg*sQg);
}
//Matrix element for q Q -> q Q, including flux and averaging factors
//See (3.23) of MadFKS
double M_q_Q_to_q_Q(
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pQin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pQout
){
const double flux = 2.*(2.*pqin.dot(pQin));
constexpr double avg = omega_q*omega_q;
return M2_qb_Qb_q_Q(-pqin,-pQin,pqout,pQout)/(flux*avg);
}
//Matrix element for q g -> q g, including flux and averaging factors
//See (3.23) of MadFKS
double M_q_g_to_q_g(
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pgin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pgout
){
const double flux = 2.*(2.*pqin.dot(pgin));
constexpr double avg = omega_q*omega_g;
return std::abs(M2_g1_qb_g2_q(-pqin,-pgin,pqout,pgout))/(flux*avg);
}
//Matrix element for q Q -> q Q g, including flux and averaging factors
//See (3.23) of MadFKS
double M_q_Q_to_q_Q_g(
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pQin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pQout,
CLHEP::HepLorentzVector const & pgout
){
const double flux = 2.*(2.*pqin.dot(pQin));
constexpr double avg = omega_q*omega_q;
return M2_qb_Qb_q_Q_g(-pqin,-pQin,pqout,pQout,pgout)/(flux*avg);
}
///// 2-parton functions /////
//Implements C+S+V terms in (4.3) of MadFKS
double Regulated_2parton_q_Q_to_q_Q(
double mur2,
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pQin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pQout
){
const double Shat = 2.*pqin.dot(pQin);
const double sqrtS = sqrt(Shat);
//We don't include Born contribution, (4.4) of MadFKS
//But we do include running coupling
const double tA= 0.;
//Collinear contribution, (4.5) of MadFKS
const double Eq = pqout.e();
const double EQ = pQout.e();
const double tC= Q_q_Q_to_q_Q(mur2, FKSParams, sqrtS, Eq, EQ);
//Soft contribution, (4.12) of MadFKS
//For eikonals we use all-outgoing flavour labels:
//i.e. kp=qbar, km=Qbar, kq=q, kQ=Q.
//We have factored out C_0 = T_F*T_F*(N_C*N_C-1.).
constexpr double C_qQbar = T_F*(N_C*N_C-2.)/N_C;
constexpr double C_qqbar = T_F*(-1.)/N_C;
constexpr double C_qQ = T_F*(-2.)/N_C;
double EikonalSum = -C_qQ*( Regulated_Integrated_Eikonal_mn(FKSParams, Shat, pqin, pQin)
+Regulated_Integrated_Eikonal_mn(FKSParams, Shat, pqout,pQout))
+C_qQbar*(Regulated_Integrated_Eikonal_mn(FKSParams, Shat, pQin, pqout)
+Regulated_Integrated_Eikonal_mn(FKSParams, Shat, pqin, pQout))
+C_qqbar*(Regulated_Integrated_Eikonal_mn(FKSParams, Shat, pqin, pqout)
+Regulated_Integrated_Eikonal_mn(FKSParams, Shat, pQin, pQout));
//Factor of 2 from (2-delta) in (3.24) of MadFKS
const double tS = 2.*EikonalSum;
//Virtual contribution (CDR Scheme)
const double tV = Regulated_Virtuals_q_Q_to_q_Q(mur2, FKSParams,pqin,pQin,pqout,pQout);
return (tA+tC+tS+tV)*M_q_Q_to_q_Q(pqin,pQin,pqout,pQout);
}
//Implements (A.6) of MadFKS (~(4.22) of FKS)
double Regulated_Integrated_Eikonal_mn(
FKSConfig const & FKSParams,
double Shat,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kn
){
const double Q2 = pow(FKSParams.Q_ES,2);
const double xi_cut = FKSParams.xi_cut;
const double arg1 = xi_cut*xi_cut*Shat/Q2;
const double arg2 = km.dot(kn)/2./km.e()/kn.e();
//Using: log(1.-z)*log(z)= M_PI*M_PI/6.-Li2(z)-Li2(1-z)
return (1./2.)*pow(log(arg1),2)+(1./2.)*pow(log(arg2),2)
+log(arg1)*log(arg2)-M_PI*M_PI/6.
+gsl_sf_dilog(1-arg2);
}
//Nonsingular part of the virtual corrections, square bracket of (2.9) of ES
//Real part has been explicitly taken below, which explains the differeing pi^2 coeffs.
//Physical process: pqin + pQin -> pqout + pQout
//ES labelling: p1 + p2 -> p3 + p4
double Regulated_Virtuals_q_Q_to_q_Q(
double mu2,
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & pqin,
CLHEP::HepLorentzVector const & pQin,
CLHEP::HepLorentzVector const & pqout,
CLHEP::HepLorentzVector const & pQout
){
const double Q2 = pow(FKSParams.Q_ES,2);
const double s= 2.*pqin.dot(pQin);
const double t= -2.*pqin.dot(pqout);
const double u= -2.*pqin.dot(pQout);
constexpr double col1 = (N_C*N_C-1)/2./N_C;
const double kin1 = -16. +log(-t/Q2)*(8.*log(s/Q2)-8.*log(-u/Q2)-2*log(-t/Q2)+6.)
-2.*(s*s-u*u)/(s*s+u*u)*(M_PI*M_PI +pow(log(-t/Q2)-log(s/Q2),2) + pow(log(-t/Q2)-log(-u/Q2),2) )
+2.*(s+u)/(s*s+u*u)*((s+u)*(log(-u/Q2)-log(s/Q2))+(u-s)*(2.*log(-t/Q2)-log(s/Q2)-log(-u/Q2)));
constexpr double col2= N_C;
const double kin2= 85./9.+M_PI*M_PI +2.*log(-t/Q2)*(log(-t/Q2)+log(-u/Q2)-2*log(s/Q2))
+(s*s-u*u)/(s*s+u*u)/2.*(1.0*M_PI*M_PI+2*pow(log(-t/Q2)-log(s/Q2),2) + pow(log(-t/Q2)-log(-u/Q2),2) )
-s*t/(s*s+u*u)*(log(-t/Q2)-log(-u/Q2))
+2.*u*t/(s*s+u*u)*(log(-t/Q2)-log(s/Q2))
+11./3.*(log(mu2/Q2)-log(-t/Q2));
constexpr double col3= 2.*N_F/3.;
const double kin3= (log(-t/Q2)-log(mu2/Q2)) -5./3.;
return col1*kin1 +col2*kin2 +col3*kin3;
}
//Helper functions for (5.6) of FKS/(4.6) of MadFKS
double Q_q(
FKSConfig const & FKSParams,
double sqrtS,
double Eq
){
const double Q2 = pow(FKSParams.Q_ES,2);
const double xi_cut = FKSParams.xi_cut;
const double delta_o = FKSParams.delta_o;
return gamma_prime_q
-log(sqrtS*sqrtS*delta_o/2./Q2)*(gamma_q-2.*C_F*log(2.*Eq/xi_cut/sqrtS))
+2.*C_F*( pow(log(2.*Eq/sqrtS),2)- pow(log(xi_cut),2) )
-2.*gamma_q*log(2.*Eq/sqrtS);
}
double Q_g(
FKSConfig const & FKSParams,
double sqrtS,
double Eg
){
const double Q2 = pow(FKSParams.Q_ES,2);
const double xi_cut = FKSParams.xi_cut;
const double delta_o = FKSParams.delta_o;
return gamma_prime_g
-log(sqrtS*sqrtS*delta_o/2./Q2)*(gamma_g-2.*C_A*log(2.*Eg/xi_cut/sqrtS))
+2.*C_A*( pow(log(2.*Eg/sqrtS),2)- pow(log(xi_cut),2) )
-2.*gamma_g*log(2.*Eg/sqrtS);
}
//Implement (5.6) of FKS
double Q_q_Q_to_q_Q(
double mur2,
FKSConfig const & FKSParams,
double sqrtS,
double Eq,
double EQ
){
const double Q2 = pow(FKSParams.Q_ES,2);
const double xi_cut = FKSParams.xi_cut;
return -log(mur2/Q2)*2.*(gamma_q +2.*C_F*log(xi_cut))
+ Q_q(FKSParams,sqrtS,Eq)
+ Q_q(FKSParams,sqrtS,EQ);
}
///// 3-parton functions /////
//Implements Lorentz invariant form of (2.78) of 0709.2092
double dip(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & ki
){
double A = FKSParams.A_FNO;
double B = FKSParams.B_FNO;
const double spi = 2.*kp.dot(ki);
const double smi = 2.*km.dot(ki);
double fA = (spi+smi)/4.;
double fB = 4.*spi/(spi+smi);
return pow(fA,A)*pow(fB,B);
}
//Implements Lorentz invariant form of (2.78) of 0709.2092
double dim(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & ki
){
double A = FKSParams.A_FNO;
double B = FKSParams.B_FNO;
const double spi = 2.*kp.dot(ki);
const double smi = 2.*km.dot(ki);
double fA = (spi+smi)/4.;
double fB = 4.*smi/(spi+smi);
return pow(fA,A)*pow(fB,B);
}
//Implements Lorentz invariant form of (2.75) of 0709.2092 with h=1
double dij(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & ki,
CLHEP::HepLorentzVector const & kj
){
double A = FKSParams.A_FNO;
double B = FKSParams.B_FNO;
const double spm = 2.*kp.dot(km);
const double sij = 2.*ki.dot(kj);
const double spi = 2.*kp.dot(ki);
const double smi = 2.*km.dot(ki);
const double spj = 2.*kp.dot(kj);
const double smj = 2.*km.dot(kj);
double fA = (spi+smi)*(spj+smj)/(4.*spm);
double fB = 2.*spm*sij/((spi+smi)*(spj+smj));
return pow(fA,A)*pow(fB,B);
}
std::vector <CLHEP::HepLorentzVector> counter_event_ISC(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & ki,
CLHEP::HepLorentzVector const & kj,
CLHEP::HepLorentzVector const & kk,
std::string type
){
//Initialise counter-event momenta
auto kib = CLHEP::HepLorentzVector(0.0, 0.0, 0.0, 0.0);
auto kjb = CLHEP::HepLorentzVector(0.0, 0.0, 0.0, 0.0);
auto kkb = CLHEP::HepLorentzVector(0.0, 0.0, 0.0, 0.0);
// Runcard parameters
double lambda_FKS = FKSParams.lambda_FKS;
double xi_s = lambda_FKS;
double zeta_p = 1.-lambda_FKS;
double zeta_m = -1.+lambda_FKS;
// Original event parameters
double sqrtS = (ki+kj+kk).m();
double xi_i = 2.*ki.e()/sqrtS;
double zeta_i = ki.pz()/ki.e();
//Rescaling factors for energy and transverse components
double r_xi = (xi_s/xi_i);
double r_perp_p = pow(1-zeta_p*zeta_p, 0.5)/pow(1-zeta_i*zeta_i, 0.5);
double r_perp_m = pow(1-zeta_m*zeta_m, 0.5)/pow(1-zeta_i*zeta_i, 0.5);
// Set kib according to counter-event type
if (type == "soft_i") {
kib = CLHEP::HepLorentzVector(r_xi*ki.px(), r_xi*ki.py(), r_xi*ki.pz(), r_xi*ki.e());
} else if (type == "col_ip") {
kib = CLHEP::HepLorentzVector(r_perp_p*ki.px(), r_perp_p*ki.py(), (sqrtS/2.)*xi_i*zeta_p,(sqrtS/2.)*xi_i);
} else if (type == "col_im") {
kib = CLHEP::HepLorentzVector(r_perp_m*ki.px(), r_perp_m*ki.py(), (sqrtS/2.)*xi_i*zeta_m,(sqrtS/2.)*xi_i);
} else if (type == "soft_col_ip") {
kib = CLHEP::HepLorentzVector(r_xi*r_perp_p*ki.px(), r_xi*r_perp_p*ki.py(), (sqrtS/2.)*xi_s*zeta_p,(sqrtS/2.)*xi_s);
} else if (type == "soft_col_im") {
kib = CLHEP::HepLorentzVector(r_xi*r_perp_m*ki.px(), r_xi*r_perp_m*ki.py(), (sqrtS/2.)*xi_s*zeta_m,(sqrtS/2.)*xi_s);
} else {
throw std::logic_error("Undefined counterevent type.");
}
// Split the remaining energy and momentum into two massless 4-momenta
// such that the original event is recovered in IR limits.
CLHEP::HepLorentzVector P = (ki+kj+kk)-kib;
//Boost to _P frame.
CLHEP::HepLorentzVector P_P = (ki+kj+kk)-kib;
CLHEP::HepLorentzVector kj_P= kj;
CLHEP::HepLorentzVector kib_P= kib;
P_P.boost(P.findBoostToCM());
kj_P.boost(P.findBoostToCM());
kib_P.boost(P.findBoostToCM());
// Give kjb_P half of the energy.
double r_j = P_P.e()/(2.*kj_P.e());
CLHEP::HepLorentzVector kjb_P = CLHEP::HepLorentzVector(r_j*kj_P.px(), r_j*kj_P.py(), r_j*kj_P.pz(), P_P.e()/2.);
CLHEP::HepLorentzVector kkb_P = CLHEP::HepLorentzVector(-kjb_P.px(), -kjb_P.py(), -kjb_P.pz(), P_P.e()/2.);
//Todo: assert(kjb_P+kkb_P = P_P)
//Outgoing momenta in P frame sum to kjb_P+kkb_P+kib_P= kib_P;
CLHEP::HepLorentzVector out_P = kjb_P+kkb_P+kib_P;
kjb =kjb_P;
kkb =kkb_P;
kjb.boost(out_P.findBoostToCM());
kkb.boost(out_P.findBoostToCM());
//Todo: assert(kib+kjb+kkb = kp+km)
return {kib,kjb,kkb};
}
void counter_event_FSC(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector & kib,
CLHEP::HepLorentzVector & kjb,
CLHEP::HepLorentzVector & kkb,
CLHEP::HepLorentzVector const & ki,
CLHEP::HepLorentzVector const & kj,
CLHEP::HepLorentzVector const & kk,
std::string type
){
double lambda_FKS = FKSParams.lambda_FKS;
double xi_s = lambda_FKS;
double zeta_cj = 1.-lambda_FKS;
double sqrtS = (ki+kj+kk).m();
double xi_i = 2.*ki.e()/sqrtS;
double xi_j = 2.*kj.e()/sqrtS;
double zeta_i = ki.z()/ki.e();
double zeta_j = kj.z()/kj.e();
double CosPhi_j = kj.x()/kj.perp();
double SinPhi_j = kj.y()/kj.perp();
//See FSC_Counterevent.nb
double zeta_ij = 1. - 4.*(ki.dot(kj))/(sqrtS*sqrtS*xi_i*xi_j);
double CosPhi_ij = (zeta_ij*zeta_j-zeta_i)/(sqrt(1.-zeta_ij*zeta_ij)*sqrt(1.-zeta_j*zeta_j));
double SinPhi_ij = (ki.y()/ki.e()-(zeta_ij*sqrt(1.-zeta_j*zeta_j)+sqrt(1.-zeta_ij*zeta_ij)*zeta_j*CosPhi_ij)*SinPhi_j)/(sqrt(1.-zeta_ij*zeta_ij)*CosPhi_j);
// Set normalised vector using j and ij parameters
std::vector <double> kihat = khat(zeta_j,CosPhi_j,SinPhi_j,zeta_ij,CosPhi_ij,SinPhi_ij);
kib = CLHEP::HepLorentzVector(0.0, 0.0, 0.0, 0.0);
if (type == "soft_i") {
kihat = khat(zeta_j,CosPhi_j,SinPhi_j,zeta_ij,CosPhi_ij,SinPhi_ij);
kib = CLHEP::HepLorentzVector((sqrtS/2.)*xi_s*kihat[0],
(sqrtS/2.)*xi_s*kihat[1],
(sqrtS/2.)*xi_s*kihat[2],
(sqrtS/2.)*xi_s);
} else if (type == "col_ij") {
kihat = khat(zeta_j,CosPhi_j,SinPhi_j,zeta_cj,CosPhi_ij,SinPhi_ij);
kib = CLHEP::HepLorentzVector((sqrtS/2.)*xi_i*kihat[0],
(sqrtS/2.)*xi_i*kihat[1],
(sqrtS/2.)*xi_i*kihat[2],
(sqrtS/2.)*xi_i);
} else if (type == "soft_col_ij") {
kihat = khat(zeta_j,CosPhi_j,SinPhi_j,zeta_cj,CosPhi_ij,SinPhi_ij);
kib = CLHEP::HepLorentzVector((sqrtS/2.)*xi_s*kihat[0],
(sqrtS/2.)*xi_s*kihat[1],
(sqrtS/2.)*xi_s*kihat[2],
(sqrtS/2.)*xi_s);
} else {
throw std::logic_error("Undefined counterevent type.");
}
//Remaining two momenta
CLHEP::HepLorentzVector P = (ki+kj+kk)-kib;
double Px = P.px();
double Py = P.py();
double Pp = P.e()+P.pz();
double Pm = P.e()-P.pz();
// Pick kjbx = kjx and kjby = kjy
double ktj = pow(kj.px()*kj.px()+kj.py()*kj.py(), 0.5);
//Determine transverse componens of kkb by momentum conservation
double kkbx = Px-kj.px();
double kkby = Py-kj.py();
double ktkb = pow(kkbx*kkbx+kkby*kkby, 0.5);
//Solve quadratic (Pp - ktjb Yjb) (Pm - ktjb/Yjb)=ktkb^2 for Yjb
//where Yj:=exp(yj)
double a = ktj*Pm;
double b = ktkb*ktkb-ktj*ktj-Pp*Pm;
double c = ktj*Pp;
//Take the more positive solution for Yjb
double Yjb = (-b+sqrt(b*b-4.*a*c))/(2.*a);
double yjb = log(Yjb);
double Ykb = ktkb/(Pm-ktj/exp(yjb));
double ykb = log(Ykb);
kjb = CLHEP::HepLorentzVector(kj.px(), kj.py() , ktj*sinh(yjb), ktj*cosh(yjb));
kkb = CLHEP::HepLorentzVector(kkbx, kkby , ktkb*sinh(ykb), ktkb*cosh(ykb));
}
std::vector <double> khat(
const double zeta_j,
const double CosPhi_j,
const double SinPhi_j,
const double zeta_ij,
const double CosPhi_ij,
const double SinPhi_ij
){
double kihatx;
double kihaty;
double kihatz;
//Shorthand for transverse magnitude
double t_j =std::sqrt(1.-zeta_j*zeta_j);
double t_ij =std::sqrt(1.-zeta_ij*zeta_ij);
kihatx = zeta_ij*t_j*CosPhi_j+t_ij*zeta_j*CosPhi_ij*CosPhi_j-t_ij*SinPhi_ij*SinPhi_j;
kihaty = zeta_ij*t_j*SinPhi_j+t_ij*zeta_j*CosPhi_ij*SinPhi_j+t_ij*SinPhi_ij*CosPhi_j;
kihatz = zeta_ij*zeta_j-t_ij*t_j*CosPhi_ij;
std::vector <double> kihat = {kihatx,kihaty,kihatz};
return kihat;
}
//We try 4 different methods for splitting a massive momentum P
// into two massless momenta k1 and k2.
// We require k1=p1 and k2=p2 in the limit P=p1+p2.
std::vector <CLHEP::HepLorentzVector> SplitMassive(
CLHEP::HepLorentzVector P,
CLHEP::HepLorentzVector p1,
CLHEP::HepLorentzVector p2
){
double Pp = P.e()+P.pz();
double Pm = P.e()-P.pz();
// We need to set the 8 components
double k1x=0;
double k1y=0;
double k1z=0;
double k1e=0;
double k2x=0;
double k2y=0;
double k2z=0;
double k2e=0;
// Useful derived quanties
double k1perp, k2perp;
// Quadratic parameters
double a, b, c;
// Initialise rapidities
double Y1=0;
double Y2=0;
double y1=0;
double y2=0;
//Method 1: Chose to set k1x = p1x, k2x = p2x
k1x = p1.x();
k1y = p1.y();
k2x = P.x()-k1x;
k2y = P.y()-k1y;
//This fixes transverse momenta
k1perp = sqrt(k1x*k1x+k1y*k1y);
k2perp = sqrt(k2x*k2x+k2y*k2y);
//Solve quadratic (Pp - k1perp Y1) (Pm - k1perp/Y1)=k2perp^2 for Y1
//where Yi:=exp(yi)
a = k1perp*Pm;
b = k2perp*k2perp-k1perp*k1perp-Pp*Pm;
c = k1perp*Pp;
//Take the larger solution for Y1
Y1 = (-b+sqrt(b*b-4.*a*c))/(2.*a);
if (Y1>0){
//Positive solution found. Continue Method 1:
y1 = log(Y1);
Y2 = k2perp/(Pm-k1perp/Y1);
y2 = log(Y2);
k1e = k1perp*cosh(y1);
k1z = k1perp*sinh(y1);
k2e = k2perp*cosh(y2);
k2z = k2perp*sinh(y2);
} else {
//Method 2: Chose to set k2x = p2x, k2y = p2y
k2x = p2.x();
k2y = p2.y();
k1x = P.x()-k2x;
k1y = P.y()-k2y;
//This fixes transverse momenta
k1perp = sqrt(k1x*k1x+k1y*k1y);
k2perp = sqrt(k2x*k2x+k2y*k2y);
//Solve original quadratic
a = k1perp*Pm;
b = k2perp*k2perp-k1perp*k1perp-Pp*Pm;
c = k1perp*Pp;
//Take the more positive solution for Y1
Y1 = (-b+sqrt(b*b-4.*a*c))/(2.*a);
if (Y1>0){ // Continue Method 2:
y1 = log(Y1);
Y2 = k2perp/(Pm-k1perp/Y1);
y2 = log(Y2);
k1e = k1perp*cosh(y1);
k1z = k1perp*sinh(y1);
k2e = k2perp*cosh(y2);
k2z = k2perp*sinh(y2);
} else {
// No real positive solutions for exp(y1) found in Method 1 or 2.
//Method 3:
k1e = p1.e();
k1z = p1.z();
k2e = P.e() - p1.e();
k2z = P.z() - p1.z();
//This fixes transverse momenta
k1perp = sqrt(k1e*k1e-k1z*k1z);
k2perp = sqrt(k2e*k2e-k2z*k2z);
if (k1perp + k2perp > P.perp()){
std::cout<<"Implement Method 3."<<std::endl;
// Implement this if both Method 1 and 2 both fail.
} else {
//Method 4: We chose to set k2e = p2e and
double k2e = p2.e();
double k2z = p2.z();
double k1e = P.e() - p2.e();
double k1z = P.z() - p2.z();
//This fixes transverse momenta
double k1perp = sqrt(k1e*k1e-k1z*k1z);
double k2perp = sqrt(k2e*k2e-k2z*k2z);
if (k1perp + k2perp > P.perp()){
//Implement this if Method 1, 2 and 3 fail.
} else {
throw std::logic_error("No real positive solutions for exp(y) found in Method 1 or 2, and triangle inequality for transverse momenta is violated in Method 3 and 4.");
}
}
}
}
auto k1 = CLHEP::HepLorentzVector(k1x,k1y,k1z,k1e);
auto k2 = CLHEP::HepLorentzVector(k2x,k2y,k2z,k2e);
std::vector <CLHEP::HepLorentzVector> outgoing = {k1, k2};
return outgoing;
}
- double Mip_q_Q_to_q_Q_g(
+ double Mib_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kq,
CLHEP::HepLorentzVector const & kQ,
CLHEP::HepLorentzVector const & kg,
- std::string flavour_i
+ std::string flavour_i,
+ std::string beam
){
const double delta_i = FKSParams.delta_i;
const double xi_cut = FKSParams.xi_cut;
const double xi_s = FKSParams.lambda_FKS;
- const double zeta_c = 1. - FKSParams.lambda_FKS;
+
+ // We deal with both cases simultaneously using z = pm zeta.
+ // zeta_c := (beam == p? 1- lambda : -1 + lambda)
+ // z_c := (beam == p? zeta_c : -zeta_c)
+ const double z_c = 1. - FKSParams.lambda_FKS;
const double sqrtS = sqrt(2.*kp.dot(km));
//Initialise outgoing momenta
CLHEP::HepLorentzVector ki, kj, kk;
// Label remaining two partons j and k.
// The choice is arbitrary.
if (flavour_i == "g"){
ki=kg;
kj=kq;
kk=kQ;
} else if (flavour_i == "q"){
ki=kq;
- kj=kg;
- kk=kQ;
+ kj=kQ;
+ kk=kg;
} else if (flavour_i == "Q"){
ki=kQ;
kj=kq;
kk=kg;
}
// Original event parameters
const double xi_i = 2.*ki.e()/sqrtS;
const double zeta_i = ki.z()/ki.e();
- //Initialise counterevent momenta: soft, collinear to kp, soft and collinear to kp.
- CLHEP::HepLorentzVector kis, kjs, kks;
- CLHEP::HepLorentzVector kic, kjc, kkc;
- CLHEP::HepLorentzVector kisc, kjsc, kksc;
+ // Parameters dependent beam
+ double z_i = 0;
+ std::string c, sc;
+ if (beam == "p"){
+ c = "col_ip";
+ sc = "soft_col_ip";
+ z_i = zeta_i;
+ } else if (beam == "m"){
+ c = "col_im";
+ sc = "soft_col_im";
+ z_i = -zeta_i;
+ }
+ // Set counterevent momenta
auto Ks=counter_event_ISC(FKSParams, ki, kj, kk, "soft_i");
- kis = Ks[0];
- kjs = Ks[1];
- kks = Ks[2];
-
- auto Kc=counter_event_ISC(FKSParams, ki, kj, kk, "col_ip");
- kic = Kc[0];
- kjc = Kc[1];
- kkc = Kc[2];
-
- auto Ksc=counter_event_ISC(FKSParams, ki, kj, kk, "soft_col_ip");
- kisc = Ksc[0];
- kjsc = Ksc[1];
- kksc = Ksc[2];
+ CLHEP::HepLorentzVector kis = Ks[0];
+ CLHEP::HepLorentzVector kjs = Ks[1];
+ CLHEP::HepLorentzVector kks = Ks[2];
+
+ auto Kc=counter_event_ISC(FKSParams, ki, kj, kk, c);
+ CLHEP::HepLorentzVector kic = Kc[0];
+ CLHEP::HepLorentzVector kjc = Kc[1];
+ CLHEP::HepLorentzVector kkc = Kc[2];
+
+ auto Ksc=counter_event_ISC(FKSParams, ki, kj, kk, sc);
+ CLHEP::HepLorentzVector kisc = Ksc[0];
+ CLHEP::HepLorentzVector kjsc = Ksc[1];
+ CLHEP::HepLorentzVector kksc = Ksc[2];
//Initialise counterterms:
- double ME2dampedIS_f=0;
- double ME2dampedIS_s=0;
- double ME2dampedIS_c=0;
- double ME2dampedIS_sc=0;
+ double ME2damped_f=0;
+ double ME2damped_s=0;
+ double ME2damped_c=0;
+ double ME2damped_sc=0;
- ME2dampedIS_f = xi_i*xi_i*(1.-zeta_i)*M_q_Q_to_q_Q_g(kp,km,kq,kQ,kg);
+ ME2damped_f = xi_i*xi_i*(1.-z_i)*M_q_Q_to_q_Q_g(kp,km,kq,kQ,kg);
//Construct counterterms, placing kjbar in appropriate slot:
if (flavour_i == "g"){
- ME2dampedIS_s = xi_s*xi_s*(1.-zeta_i)*M_q_Q_to_q_Q_g(kp,km,kjs,kks,kis);
- ME2dampedIS_c = xi_i*xi_i*(1.-zeta_c)*M_q_Q_to_q_Q_g(kp,km,kjc,kkc,kic);
- ME2dampedIS_sc = xi_s*xi_s*(1.-zeta_c)*M_q_Q_to_q_Q_g(kp,km,kjsc,kksc,kisc);
+ ME2damped_s = xi_s*xi_s*(1.-z_i)*M_q_Q_to_q_Q_g(kp,km,kjs,kks,kis);
+ ME2damped_c = xi_i*xi_i*(1.-z_c)*M_q_Q_to_q_Q_g(kp,km,kjc,kkc,kic);
+ ME2damped_sc = xi_s*xi_s*(1.-z_c)*M_q_Q_to_q_Q_g(kp,km,kjsc,kksc,kisc);
} else if (flavour_i == "q"){
- ME2dampedIS_s = xi_s*xi_s*(1.-zeta_i)*M_q_Q_to_q_Q_g(kp,km,kis,kjs,kks);
- ME2dampedIS_c = xi_i*xi_i*(1.-zeta_c)*M_q_Q_to_q_Q_g(kp,km,kic,kjc,kkc);
- ME2dampedIS_sc = xi_s*xi_s*(1.-zeta_c)*M_q_Q_to_q_Q_g(kp,km,kisc,kjsc,kksc);
+ ME2damped_s = xi_s*xi_s*(1.-z_i)*M_q_Q_to_q_Q_g(kp,km,kis,kjs,kks);
+ ME2damped_c = xi_i*xi_i*(1.-z_c)*M_q_Q_to_q_Q_g(kp,km,kic,kjc,kkc);
+ ME2damped_sc = xi_s*xi_s*(1.-z_c)*M_q_Q_to_q_Q_g(kp,km,kisc,kjsc,kksc);
} else if (flavour_i == "Q"){
- ME2dampedIS_s = xi_s*xi_s*(1.-zeta_i)*M_q_Q_to_q_Q_g(kp,km,kjs,kis,kks);
- ME2dampedIS_c = xi_i*xi_i*(1.-zeta_c)*M_q_Q_to_q_Q_g(kp,km,kjc,kic,kkc);
- ME2dampedIS_sc = xi_s*xi_s*(1.-zeta_c)*M_q_Q_to_q_Q_g(kp,km,kjsc,kisc,kksc);
+ ME2damped_s = xi_s*xi_s*(1.-z_i)*M_q_Q_to_q_Q_g(kp,km,kjs,kis,kks);
+ ME2damped_c = xi_i*xi_i*(1.-z_c)*M_q_Q_to_q_Q_g(kp,km,kjc,kic,kkc);
+ ME2damped_sc = xi_s*xi_s*(1.-z_c)*M_q_Q_to_q_Q_g(kp,km,kjsc,kisc,kksc);
} else {
throw std::logic_error("Parton type not in {q,Q,g}");
}
- //std::cout<<"ME_f = "<< ME2dampedIS_f << std::endl;
- //std::cout<<"ME_s = "<< ME2dampedIS_s << std::endl;
- //std::cout<<"ME_c = "<< ME2dampedIS_c << std::endl;
- //std::cout<<"ME_sc = "<< ME2dampedIS_sc << std::endl;
+ //std::cout<<"ME_f = "<< ME2damped_f << std::endl;
+ //std::cout<<"ME_s = "<< ME2damped_s << std::endl;
+ //std::cout<<"ME_c = "<< ME2damped_c << std::endl;
+ //std::cout<<"ME_sc = "<< ME2damped_sc << std::endl;
double MEsum = 0.;
//Add the contributions
if(xi_i>xi_cut){
- if(zeta_i<1.-delta_i){
- MEsum += ME2dampedIS_f;
+ if(z_i<1.-delta_i){
+ MEsum += ME2damped_f;
} else {
- MEsum += ME2dampedIS_f - ME2dampedIS_c;
+ MEsum += ME2damped_f - ME2damped_c;
}
} else { //xij<xicut
- if(zeta_i<1.-delta_i){
- MEsum += ME2dampedIS_f - ME2dampedIS_s;
+ if(z_i<1.-delta_i){
+ MEsum += ME2damped_f - ME2damped_s;
} else {
- MEsum += ME2dampedIS_f - ME2dampedIS_s - ME2dampedIS_c + ME2dampedIS_sc;
+ MEsum += ME2damped_f - ME2damped_s - ME2damped_c + ME2damped_sc;
}
}
- return MEsum/(xi_i*xi_i*(1-zeta_i));
+ return MEsum/(xi_i*xi_i*(1-z_i));
}
//'Plus distribution'-regulated Matrix elements
double Mgj_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kq,
CLHEP::HepLorentzVector const & kQ,
CLHEP::HepLorentzVector const & kg,
std::string flavour_j
){
const double delta_o = FKSParams.delta_o;
const double xi_cut = FKSParams.xi_cut;
const double xi_s = FKSParams.lambda_FKS;
const double zeta_cj = 1. - FKSParams.lambda_FKS;
const double sqrtS = sqrt(2.*kp.dot(km));
//Initialise outgoing momenta
CLHEP::HepLorentzVector ki, kj, kk;
ki=kg;
if (flavour_j == "q" ){
kj=kq;
kk=kQ;
} else if (flavour_j == "Q"){
kj=kQ;
kk=kq;
} else {
throw std::logic_error("Invalid parton type.");
}
// Original event parameters
const double xi_i = 2.*ki.e()/sqrtS;
const double zeta_ij = 1.-ki.dot(kj)/(ki.e()*kj.e());
//Initialise counterevent momenta: soft, collinear to kp, soft and collinear to kp.
CLHEP::HepLorentzVector kis, kjs, kks;
CLHEP::HepLorentzVector kic, kjc, kkc;
CLHEP::HepLorentzVector kisc, kjsc, kksc;
counter_event_FSC(FKSParams, kis, kjs, kks, ki, kj, kk, "soft_i");
counter_event_FSC(FKSParams, kic, kjc, kkc, ki, kj, kk, "col_ij");
counter_event_FSC(FKSParams, kisc, kjsc, kksc, ki, kj, kk, "soft_col_ij");
//Initialise counterterms:
double ME2damped_f=0;
double ME2damped_s=0;
double ME2damped_c=0;
double ME2damped_sc=0;
ME2damped_f = xi_i*xi_i*(1.-zeta_ij)*M_q_Q_to_q_Q_g(kp,km,kq,kQ,kg);
//Construct counterterms, placing kjbar in appropriate slot:
if (flavour_j == "q"){
ME2damped_s = xi_s*xi_s*(1.-zeta_ij)*M_q_Q_to_q_Q_g(kp,km,kjs,kks,kis);
ME2damped_c = xi_i*xi_i*(1.-zeta_cj)*M_q_Q_to_q_Q_g(kp,km,kjc,kkc,kic);
ME2damped_sc = xi_s*xi_s*(1.-zeta_cj)*M_q_Q_to_q_Q_g(kp,km,kjsc,kksc,kisc);
} else if (flavour_j == "Q"){
ME2damped_s = xi_s*xi_s*(1.-zeta_ij)*M_q_Q_to_q_Q_g(kp,km,kks,kjs,kis);
ME2damped_c = xi_i*xi_i*(1.-zeta_cj)*M_q_Q_to_q_Q_g(kp,km,kkc,kjc,kic);
ME2damped_sc = xi_s*xi_s*(1.-zeta_cj)*M_q_Q_to_q_Q_g(kp,km,kksc,kjsc,kisc);
} else {
throw std::logic_error("Parton type not in {q,Q,g}");
}
//Add the contributions
double MEsum = 0.;
if (xi_i>xi_cut) {
if(zeta_ij<1.-delta_o){
MEsum += ME2damped_f;
} else {
MEsum += ME2damped_f-ME2damped_c;
}
} else { //xig<xicut
if(zeta_ij<1.-delta_o){
MEsum += ME2damped_f-ME2damped_s;
} else {
MEsum += ME2damped_f-ME2damped_s-ME2damped_c+ME2damped_sc;
}
}
return MEsum/((1.-zeta_ij)*xi_i*xi_i);
}
//ISC remnant
//q(p) -> q(zp) [+g((1-z)p)]
double Pqq(
double z
){
return C_F*(1.+z*z)/(1.-z);
}
//q(p) -> g(zp) [+q((1-z)p)]
double Pqg(
double z
){
return C_F*(1.+(1.-z)*(1.-z))/z;
}
double Ggp_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
CLHEP::HepLorentzVector const & kq,
CLHEP::HepLorentzVector const & kQ,
const double zeta_g,
const double mur2
){
const double z = zeta_g;
const double delta_i = FKSParams.delta_i;
const double xi_cut = FKSParams.xi_cut;
const double sqQ = 2.*kq.dot(kQ);
double term1 = (1.-z)*Pqq(z)*log(sqQ*delta_i/(2.*z*mur2));
if (1. - z < xi_cut){
term1 -= 2.*C_F*log(sqQ*delta_i/(2.*mur2));
}
term1 /= (1.-z);
double term2 = 2.*(1.-z)*Pqq(z);
if (1. - z < xi_cut){
term2 -= 4.*C_F*z;
}
term2 *= log(1.-z)/(1.-z);
double term3 = -1.*(-C_F*(1.-z));
return (term1+term2+term3)*M_q_Q_to_q_Q(kq+kQ-km,km,kq,kQ);
}
double Gqp_q_Q_to_q_Q_g(
FKSConfig const & FKSParams,
CLHEP::HepLorentzVector const & kp,
CLHEP::HepLorentzVector const & km,
const double zeta_q,
CLHEP::HepLorentzVector const & kQ,
CLHEP::HepLorentzVector const & kg,
const double mur2
){
const double z = zeta_q;
const double delta_i = FKSParams.delta_i;
const double xi_cut = FKSParams.xi_cut;
const double sQg = 2.*kQ.dot(kg);
double term1 = (1.-z)*Pqg(z)*log(sQg*delta_i/(2.*z*mur2));
if (1. - z < xi_cut){
term1 -= 0;
}
term1 /= (1.-z);
double term2 = 2.*(1.-z)*Pqg(z);
if (1. - z < xi_cut){
term2 -= 2.*C_F*(1.-z);
}
term2 *= log(1.-z)/(1.-z);
double term3 = -1.*(-C_F*z);
return (term1+term2+term3)*M_q_g_to_q_g(kg+kQ-km,km,kQ,kg);
}
} }

File Metadata

Mime Type
text/x-diff
Expires
Thu, Apr 24, 6:37 AM (1 d, 21 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4887793
Default Alt Text
(52 KB)

Event Timeline