No OneTemporary
Actions

Size

289 KB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/FixedOrderGen/include/PhaseSpacePoint.hh b/FixedOrderGen/include/PhaseSpacePoint.hh
	index 2645b40..a55516c 100644
	--- a/FixedOrderGen/include/PhaseSpacePoint.hh
	+++ b/FixedOrderGen/include/PhaseSpacePoint.hh
	@@ -1,187 +1,188 @@
	/** \file PhaseSpacePoint.hh
	* \brief Contains the PhaseSpacePoint Class
	*/

	#pragma once

	#include <vector>

	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/Event.hh"
	#include "HEJ/PDG_codes.hh"
	#include "HEJ/PDF.hh"
	+#include "HEJ/Particle.hh"
	#include "HEJ/RNG.hh"

	#include "Status.hh"
	#include "JetParameters.hh"
	#include "ParticleProperties.hh"

	namespace HEJFOG{
	class Process;

	using HEJ::Particle;
	//! A point in resummation phase space
	class PhaseSpacePoint{
	public:
	//! Default PhaseSpacePoint Constructor
	PhaseSpacePoint() = default;

	//! PhaseSpacePoint Constructor
	/**
	* @param proc The process to generate
	* @param jet_properties Jet defintion & cuts
	* @param pdf The pdf set (used for sampling)
	* @param E_beam Energie of the beam
	* @param subl_chance Chance to turn a potentially unordered
	* emission into an actual one
	* @param subl_channels Possible subleading channels.
	* see HEJFOG::Subleading
	* @param particle_properties Properties of producted boson
	*
	* Initially, only FKL phase space points are generated. If the most
	* extremal emission in any direction is a quark or anti-quark and the
	* next emission is a gluon, subl_chance is the chance to turn this into
	* an unordered emission event by swapping the two flavours. At most one
	* unordered emission will be generated in this way.
	*/
	PhaseSpacePoint(
	Process const & proc,
	JetParameters const & jet_properties,
	HEJ::PDF & pdf, double E_beam,
	double subl_chance,
	unsigned int subl_channels,
	ParticlesPropMap const & particles_properties,
	HEJ::RNG & ran
	);

	//! Get Weight Function
	/**
	* @returns Weight of Event
	*/
	double weight() const{
	return weight_;
	}

	Status status() const{
	return status_;
	}

	//! Get Incoming Function
	/**
	* @returns Incoming Particles
	*/
	std::array<Particle, 2> const & incoming() const{
	return incoming_;
	}

	//! Get Outgoing Function
	/**
	* @returns Outgoing Particles
	*/
	std::vector<Particle> const & outgoing() const{
	return outgoing_;
	}

	std::unordered_map<size_t, std::vector<Particle>> const & decays() const{
	return decays_;
	}

	private:
	/**
	* \internal
	* \brief Generate LO parton momentum
	*
	* @param count Number of partons to generate
	* @param is_pure_jets If true ensures momentum conservation in x and y
	* @param jet_param Jet properties to fulfil
	* @param max_pt max allowed pt for a parton (typically E_CMS)
	* @param ran Random Number Generator
	*
	* @returns Momentum of partons
	*
	* Ensures that each parton is in its own jet.
	* Generation is independent of parton flavour. Output is sorted in rapidity.
	*/
	std::vector<fastjet::PseudoJet> gen_LO_partons(
	int count, bool is_pure_jets,
	JetParameters const & jet_param,
	double max_pt,
	HEJ::RNG & ran
	);
	Particle gen_boson(
	HEJ::ParticleID bosonid, double mass, double width,
	HEJ::RNG & ran
	);
	template<class ParticleMomenta>
	fastjet::PseudoJet gen_last_momentum(
	ParticleMomenta const & other_momenta,
	double mass_square, double y
	) const;

	bool jets_ok(
	std::vector<fastjet::PseudoJet> const & Born_jets,
	std::vector<fastjet::PseudoJet> const & partons
	) const;
	/**
	* \internal
	* \brief Generate incoming partons according to the PDF
	*
	* @param uf Scale used in the PDF
	*/
	void reconstruct_incoming(
	std::array<HEJ::ParticleID, 2> const & ids,
	HEJ::PDF & pdf, double E_beam,
	double uf,
	HEJ::RNG & ran
	);
	HEJ::ParticleID generate_incoming_id(
	size_t beam_idx, double x, double uf, HEJ::PDF & pdf,
	HEJ::RNG & ran
	);

	bool momentum_conserved(double ep) const;

	HEJ::Particle const & most_backward_FKL(
	std::vector<HEJ::Particle> const & partons
	) const;
	HEJ::Particle const & most_forward_FKL(
	std::vector<HEJ::Particle> const & partons
	) const;
	HEJ::Particle & most_backward_FKL(std::vector<HEJ::Particle> & partons) const;
	HEJ::Particle & most_forward_FKL(std::vector<HEJ::Particle> & partons) const;
	bool extremal_FKL_ok(
	std::vector<fastjet::PseudoJet> const & partons
	) const;
	double random_normal(double stddev, HEJ::RNG & ran);
	void maybe_turn_to_uno(double chance, HEJ::RNG & ran);
	std::vector<Particle> decay_boson(
	HEJ::Particle const & parent,
	std::vector<Decay> const & decays,
	HEJ::RNG & ran
	);
	Decay select_decay_channel(
	std::vector<Decay> const & decays,
	HEJ::RNG & ran
	);
	double gen_hard_pt(
	int np, double ptmin, double ptmax, double y,
	HEJ::RNG & ran
	);
	double gen_soft_pt(int np, double ptmax, HEJ::RNG & ran);
	double gen_parton_pt(
	int count, JetParameters const & jet_param, double ptmax, double y,
	HEJ::RNG & ran
	);


	double weight_;

	Status status_;

	std::array<Particle, 2> incoming_;
	std::vector<Particle> outgoing_;
	//! Particle decays in the format {outgoing index, decay products}
	std::unordered_map<size_t, std::vector<Particle>> decays_;
	};
	HEJ::UnclusteredEvent to_UnclusteredEvent(PhaseSpacePoint const & psp);
	}
	diff --git a/FixedOrderGen/src/PhaseSpacePoint.cc b/FixedOrderGen/src/PhaseSpacePoint.cc
	index 4182985..91ccf9a 100644
	--- a/FixedOrderGen/src/PhaseSpacePoint.cc
	+++ b/FixedOrderGen/src/PhaseSpacePoint.cc
	@@ -1,459 +1,460 @@
	#include "PhaseSpacePoint.hh"

	#include <random>

	#include "HEJ/kinematics.hh"
	#include "HEJ/utility.hh"
	#include "HEJ/exceptions.hh"
	+#include "HEJ/Particle.hh"

	#include "Process.hh"
	#include "Subleading.hh"

	#include <CLHEP/Random/Randomize.h>
	#include <CLHEP/Random/RanluxEngine.h>

	using namespace HEJ;

	namespace HEJFOG{

	static_assert(
	std::numeric_limits<double>::has_quiet_NaN,
	"no quiet NaN for double"
	);
	constexpr double NaN = std::numeric_limits<double>::quiet_NaN();
	HEJ::UnclusteredEvent to_UnclusteredEvent(PhaseSpacePoint const & psp){
	HEJ::UnclusteredEvent result;
	result.incoming = psp.incoming();
	std::sort(
	begin(result.incoming), end(result.incoming),
	[](Particle o1, Particle o2){return o1.p.pz()<o2.p.pz();}
	);
	assert(result.incoming.size() == 2);
	result.outgoing = psp.outgoing();
	assert(
	std::is_sorted(
	begin(result.outgoing), end(result.outgoing),
	HEJ::rapidity_less{}
	)
	);
	assert(result.outgoing.size() >= 2);
	result.decays = psp.decays();
	result.central.mur = NaN;
	result.central.muf = NaN;
	result.central.weight = psp.weight();
	return result;
	}

	namespace{
	bool can_swap_to_uno(
	HEJ::Particle const & p1, HEJ::Particle const & p2
	){
	return is_parton(p1)
	&& p1.type != HEJ::pid::gluon
	&& p2.type == HEJ::pid::gluon;
	}
	}

	void PhaseSpacePoint::maybe_turn_to_uno(
	double chance,
	HEJ::RNG & ran
	){
	assert(outgoing_.size() >= 2);
	const size_t nout = outgoing_.size();
	const bool can_be_uno_backward = can_swap_to_uno(
	outgoing_[0], outgoing_[1]
	);
	const bool can_be_uno_forward = can_swap_to_uno(
	outgoing_[nout-1], outgoing_[nout-2]
	);
	if(!can_be_uno_backward && !can_be_uno_forward) return;
	if(ran.flat() < chance){
	weight_ /= chance;
	if(can_be_uno_backward && can_be_uno_forward){
	if(ran.flat() < 0.5){
	std::swap(outgoing_[0].type, outgoing_[1].type);
	}
	else{
	std::swap(outgoing_[nout-1].type, outgoing_[nout-2].type);
	}
	weight_ *= 2.;
	}
	else if(can_be_uno_backward){
	std::swap(outgoing_[0].type, outgoing_[1].type);
	}
	else{
	assert(can_be_uno_forward);
	std::swap(outgoing_[nout-1].type, outgoing_[nout-2].type);
	}
	}
	else weight_ /= 1 - chance;
	}

	template<class ParticleMomenta>
	fastjet::PseudoJet PhaseSpacePoint::gen_last_momentum(
	ParticleMomenta const & other_momenta,
	const double mass_square, const double y
	) const {
	std::array<double,2> pt{0.,0.};
	for (auto const & p: other_momenta) {
	pt[0]-= p.px();
	pt[1]-= p.py();
	}

	const double mperp = sqrt(pt[0]pt[0]+pt[1]pt[1]+mass_square);
	const double pz=mperp*sinh(y);
	const double E=mperp*cosh(y);

	return {pt[0], pt[1], pz, E};
	}

	PhaseSpacePoint::PhaseSpacePoint(
	Process const & proc,
	JetParameters const & jet_param,
	HEJ::PDF & pdf, double E_beam,
	double subl_change,
	unsigned int subl_channels,
	ParticlesPropMap const & particles_properties,
	HEJ::RNG & ran
	)
	{
	assert(proc.njets >= 2);
	if(proc.boson
	&& particles_properties.find(*(proc.boson))
	== particles_properties.end())
	throw HEJ::missing_option("Boson "
	+std::to_string(*(proc.boson))+" can't be generated: missing properties");
	status_ = good;
	weight_ = 1;

	const int nout = proc.njets + (proc.boson?1:0);
	outgoing_.reserve(nout);

	const bool is_pure_jets = !proc.boson;
	auto partons = gen_LO_partons(
	proc.njets, is_pure_jets, jet_param, E_beam, ran
	);
	for(auto&& p_out: partons) {
	outgoing_.emplace_back(Particle{pid::gluon, std::move(p_out)});
	}
	if(status_ != good) return;

	// create boson
	if(proc.boson){
	const auto & boson_prop = particles_properties.at(*proc.boson);
	auto boson(gen_boson(*proc.boson, boson_prop.mass, boson_prop.width, ran));
	const auto pos = std::upper_bound(
	begin(outgoing_),end(outgoing_),boson,rapidity_less{}
	);
	outgoing_.insert(pos, std::move(boson));
	if(! boson_prop.decays.empty()){
	const size_t boson_idx = std::distance(begin(outgoing_), pos);
	decays_.emplace(
	boson_idx,
	decay_boson(outgoing_[boson_idx], boson_prop.decays, ran)
	);
	}
	}
	// normalisation of momentum-conserving delta function
	weight_ = pow(2M_PI, 4);

	reconstruct_incoming(proc.incoming, pdf, E_beam, jet_param.min_pt, ran);
	if(status_ != good) return;
	// set outgoing states
	most_backward_FKL(outgoing_).type = incoming_[0].type;
	most_forward_FKL(outgoing_).type = incoming_[1].type;

	if(proc.njets > 2 && subl_channels & Subleading::uno) maybe_turn_to_uno(subl_change, ran);
	}

	double PhaseSpacePoint::gen_hard_pt(
	int np , double ptmin, double ptmax, double y,
	HEJ::RNG & ran
	) {
	// heuristic parameters for pt sampling
	const double ptpar = ptmin + np/5.;
	const double arg_small_y = atan((ptmax - ptmin)/ptpar);
	const double y_cut = 3.;

	const double r1 = ran.flat();
	if(y < y_cut){
	const double pt = ptmin + ptpartan(r1arg_small_y);
	const double temp = cos(r1*arg_small_y);
	weight_ = ptptpararg_small_y/(temptemp);
	return pt;
	}

	const double ptpar2 = ptpar/(1 + 5*(y-y_cut));
	const double temp = 1. - std::exp((ptmin-ptmax)/ptpar2);
	const double pt = ptmin - ptpar2std::log(1-r1temp);
	weight_ = ptptpar2temp/(1-r1temp);
	return pt;
	}

	double PhaseSpacePoint::gen_soft_pt(int np, double max_pt, HEJ::RNG & ran) {
	constexpr double ptpar = 4.;

	const double r = ran.flat();
	const double pt = max_pt + ptpar/np*std::log(r);
	weight_ = ptptpar/(np*r);
	return pt;
	}

	double PhaseSpacePoint::gen_parton_pt(
	int count, JetParameters const & jet_param, double max_pt, double y,
	HEJ::RNG & ran
	) {
	constexpr double p_small_pt = 0.02;

	if(! jet_param.peak_pt) {
	return gen_hard_pt(count, jet_param.min_pt, max_pt, y, ran);
	}
	const double r = ran.flat();
	if(r > p_small_pt) {
	weight_ /= 1. - p_small_pt;
	return gen_hard_pt(count, *jet_param.peak_pt, max_pt, y, ran);
	}
	weight_ /= p_small_pt;
	const double pt = gen_soft_pt(count, *jet_param.peak_pt, ran);
	if(pt < jet_param.min_pt) {
	weight_=0.0;
	status_ = not_enough_jets;
	return jet_param.min_pt;
	}
	return pt;
	}

	std::vector<fastjet::PseudoJet> PhaseSpacePoint::gen_LO_partons(
	int np, bool is_pure_jets,
	JetParameters const & jet_param,
	double max_pt,
	HEJ::RNG & ran
	){
	if (np<2) throw std::invalid_argument{"Not enough partons in gen_LO_partons"};

	weight_ /= pow(16.*pow(M_PI,3),np);
	weight_ /= std::tgamma(np+1); //remove rapidity ordering
	std::vector<fastjet::PseudoJet> partons;
	partons.reserve(np);
	for(int i = 0; i < np; ++i){
	const double y = -jet_param.max_y + 2jet_param.max_yran.flat();
	weight_ = 2jet_param.max_y;

	const bool is_last_parton = i+1 == np;
	if(is_pure_jets && is_last_parton) {
	constexpr double parton_mass_sq = 0.;
	partons.emplace_back(gen_last_momentum(partons, parton_mass_sq, y));
	break;
	}

	const double phi = 2M_PIran.flat();
	weight_ = 2.0M_PI;

	const double pt = gen_parton_pt(np, jet_param, max_pt, y, ran);
	if(weight_ == 0.0) return {};

	partons.emplace_back(fastjet::PtYPhiM(pt, y, phi));
	assert(jet_param.min_pt <= partons[i].pt());
	assert(partons[i].pt() <= max_pt+1e-5);
	}
	// Need to check that at LO, the number of jets = number of partons;
	fastjet::ClusterSequence cs(partons, jet_param.def);
	auto cluster_jets=cs.inclusive_jets(jet_param.min_pt);
	if (cluster_jets.size()!=unsigned(np)){
	weight_=0.0;
	status_ = not_enough_jets;
	return {};
	}

	std::sort(begin(partons), end(partons), rapidity_less{});

	return partons;
	}

	Particle PhaseSpacePoint::gen_boson(
	HEJ::ParticleID bosonid, double mass, double width,
	HEJ::RNG & ran
	){
	if(bosonid != HEJ::pid::Higgs)
	throw HEJ::not_implemented("Production of boson "+std::to_string(bosonid)
	+" not implemented yet.");
	// Usual phase space measure
	weight_ /= 16.*pow(M_PI, 3);

	// Generate a y Gaussian distributed around 0
	// TODO: magic number only for Higgs
	const double y = random_normal(1.6, ran);
	const double r1 = ran.flat();
	const double sH = mass*(
	mass + widthtan(M_PI/2.r1 + (r1-1.)*atan(mass/width))
	);

	auto p = gen_last_momentum(outgoing_, sH, y);

	return Particle{bosonid, std::move(p)};
	}

	Particle const & PhaseSpacePoint::most_backward_FKL(
	std::vector<Particle> const & partons
	) const{
	if(!HEJ::is_parton(partons[0])) return partons[1];
	return partons[0];
	}

	Particle const & PhaseSpacePoint::most_forward_FKL(
	std::vector<Particle> const & partons
	) const{
	const size_t last_idx = partons.size() - 1;
	if(!HEJ::is_parton(partons[last_idx])) return partons[last_idx-1];
	return partons[last_idx];
	}

	Particle & PhaseSpacePoint::most_backward_FKL(
	std::vector<Particle> & partons
	) const{
	if(!HEJ::is_parton(partons[0])) return partons[1];
	return partons[0];
	}

	Particle & PhaseSpacePoint::most_forward_FKL(
	std::vector<Particle> & partons
	) const{
	const size_t last_idx = partons.size() - 1;
	if(!HEJ::is_parton(partons[last_idx])) return partons[last_idx-1];
	return partons[last_idx];
	}

	void PhaseSpacePoint::reconstruct_incoming(
	std::array<HEJ::ParticleID, 2> const & ids,
	HEJ::PDF & pdf, double E_beam,
	double uf,
	HEJ::RNG & ran
	){
	std::tie(incoming_[0].p, incoming_[1].p) = incoming_momenta(outgoing_);
	// calculate xa, xb
	const double sqrts=2*E_beam;
	const double xa=(incoming_[0].p.e()-incoming_[0].p.pz())/sqrts;
	const double xb=(incoming_[1].p.e()+incoming_[1].p.pz())/sqrts;
	// abort if phase space point is outside of collider energy reach
	if (xa>1. \|\| xb>1.){
	weight_=0;
	status_ = too_much_energy;
	return;
	}
	// pick pdfs
	/** @TODO:
	* ufa, ufb don't correspond to our final scale choice.
	* The HEJ scale generators currently expect a full event as input,
	* so fixing this is not completely trivial
	*/
	for(size_t i = 0; i < 2; ++i){
	if(ids[i] == pid::proton \|\| ids[i] == pid::p_bar){
	incoming_[i].type = generate_incoming_id(i, i?xb:xa, uf, pdf, ran);
	}
	else {
	incoming_[i].type = ids[i];
	}
	}
	assert(momentum_conserved(1e-7));
	}

	namespace {
	/// particles are ordered, odd = anti
	ParticleID index_to_pid(size_t i){
	if(!i) return pid::gluon;
	return static_cast<ParticleID>(i%2?(i+1)/2:-i/2);
	}
	}

	HEJ::ParticleID PhaseSpacePoint::generate_incoming_id(
	size_t const beam_idx, double const x, double const uf,
	HEJ::PDF & pdf, HEJ::RNG & ran
	){
	std::array<double,11> pdf_wt;
	pdf_wt[0] = fabs(pdf.pdfpt(beam_idx,x,uf,pid::gluon));
	double pdftot = pdf_wt[0];
	for(size_t i = 1; i < pdf_wt.size(); ++i){
	pdf_wt[i] = 4./9.*fabs(pdf.pdfpt(beam_idx,x,uf,index_to_pid(i)));
	pdftot += pdf_wt[i];
	}
	const double r1 = pdftot * ran.flat();
	double sum = 0;
	for(size_t i=0; i < pdf_wt.size(); ++i){
	if (r1 < (sum+=pdf_wt[i])){
	weight_*= pdftot/pdf_wt[i];
	return index_to_pid(i);
	}
	}
	std::cerr << "Error in choosing incoming parton: "<<x<<" "<<uf<<" "
	<<sum<<" "<<pdftot<<" "<<r1<<std::endl;
	throw std::logic_error{"Failed to choose parton flavour"};
	}

	double PhaseSpacePoint::random_normal(
	double stddev,
	HEJ::RNG & ran
	){
	const double r1 = ran.flat();
	const double r2 = ran.flat();
	const double lninvr1 = -log(r1);
	const double result = stddevsqrt(2.lninvr1)cos(2.M_PI*r2);
	weight_ = exp(resultresult/(2stddevstddev))sqrt(2.M_PI)*stddev;
	return result;
	}

	bool PhaseSpacePoint::momentum_conserved(double ep) const{
	fastjet::PseudoJet diff;
	for(auto const & in: incoming()) diff += in.p;
	for(auto const & out: outgoing()) diff -= out.p;
	return nearby_ep(diff, fastjet::PseudoJet{}, ep);
	}

	Decay PhaseSpacePoint::select_decay_channel(
	std::vector<Decay> const & decays,
	HEJ::RNG & ran
	){
	double br_total = 0.;
	for(auto const & decay: decays) br_total += decay.branching_ratio;
	// adjust weight
	// this is given by (channel branching ratio)/(chance to pick channel)
	// where (chance to pick channel) =
	// (channel branching ratio)/(total branching ratio)
	weight_ *= br_total;
	const double r1 = br_total*ran.flat();
	double br_sum = 0.;
	for(auto const & decay: decays){
	br_sum += decay.branching_ratio;
	if(r1 < br_sum) return decay;
	}
	throw std::logic_error{"unreachable"};
	}

	std::vector<Particle> PhaseSpacePoint::decay_boson(
	HEJ::Particle const & parent,
	std::vector<Decay> const & decays,
	HEJ::RNG & ran
	){
	const auto channel = select_decay_channel(decays, ran);
	if(channel.products.size() != 2){
	throw HEJ::not_implemented{
	"only decays into two particles are implemented"
	};
	}
	std::vector<Particle> decay_products(channel.products.size());
	for(size_t i = 0; i < channel.products.size(); ++i){
	decay_products[i].type = channel.products[i];
	}
	// choose polar and azimuth angle in parent rest frame
	const double E = parent.m()/2;
	const double theta = 2.M_PIran.flat();
	const double cos_phi = 2.*ran.flat()-1.;
	const double sin_phi = sqrt(1. - cos_phi*cos_phi); // Know 0 < phi < pi
	const double px = Ecos(theta)sin_phi;
	const double py = Esin(theta)sin_phi;
	const double pz = E*cos_phi;
	decay_products[0].p.reset(px, py, pz, E);
	decay_products[1].p.reset(-px, -py, -pz, E);
	for(auto & particle: decay_products) particle.p.boost(parent.p);
	return decay_products;
	}
	}
	diff --git a/FixedOrderGen/src/main.cc b/FixedOrderGen/src/main.cc
	index 3cbd54b..2edd4fa 100644
	--- a/FixedOrderGen/src/main.cc
	+++ b/FixedOrderGen/src/main.cc
	@@ -1,248 +1,248 @@
	/**
	* Name: main.cc
	* Authors: Jeppe R. Andersen
	*/

	#include <fstream>
	#include <algorithm>
	#include <memory>
	#include <chrono>
	#include <iostream>
	#include <map>

	#include "yaml-cpp/yaml.h"

	#include "config.hh"

	#include "LHEF/LHEF.h"
	#include "HEJ/CombinedEventWriter.hh"
	#include "HEJ/get_analysis.hh"
	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	//#include "HEJ/EventReweighter.hh"
	#include "HEJ/stream.hh"
	#include "HEJ/LesHouchesWriter.hh"
	#include "HEJ/ProgressBar.hh"
	#include "HEJ/make_RNG.hh"

	#include "EventGenerator.hh"
	#include "PhaseSpacePoint.hh"
	#include "Unweighter.hh"
	#include "CrossSectionAccumulator.hh"
	#include "Version.hh"

	namespace{
	constexpr auto banner =
	" __ ___ __ ______ __ __ \n"
	" / / / (_)___ _/ /_ / ____/___ ___ _________ ___ __ / /__ / /______ \n"
	" / /_/ / / __ `/ __ \\ / __/ / __ \\/ _ \\/ ___/ __ `/ / / / __ / / _ \\/ __/ ___/ \n"
	" / __ / / /_/ / / / / / /___/ / / / __/ / / /_/ / /_/ / / /_/ / __/ /_(__ ) \n"
	" /_/ /_/_/\\__, /_/ /_/ /_____/_/ /_/\\___/_/ \\__, /\\__, / \\____/\\___/\\__/____/ \n"
	" ____///__/ __ ____ ///__//____/ ______ __ \n"
	" / ____(_) _____ ____/ / / __ \\_________/ /__ _____ / ____/__ ____ ___ _________ _/ /_____ _____\n"
	" / /_ / / \|/_/ _ \\/ __ / / / / / ___/ __ / _ \\/ ___/ / / __/ _ \\/ __ \\/ _ \\/ ___/ __ `/ __/ __ \\/ ___/\n"
	" / __/ / /> </ __/ /_/ / / /_/ / / / /_/ / __/ / / /_/ / __/ / / / __/ / / /_/ / /_/ /_/ / / \n"
	" /_/ /_/_/\|_\|\\___/\\__,_/ \\____/_/ \\__,_/\\___/_/ \\____/\\___/_/ /_/\\___/_/ \\__,_/\\__/\\____/_/ \n"
	;

	constexpr double invGeV2_to_pb = 389379292.;
	constexpr long long max_warmup_events = 10000;
	}

	HEJFOG::Config load_config(char const * filename){
	try{
	return HEJFOG::load_config(filename);
	}
	catch(std::exception const & exc){
	std::cerr << "Error: " << exc.what() << '\n';
	std::exit(EXIT_FAILURE);
	}
	}

	std::unique_ptr<HEJ::Analysis> get_analysis(
	YAML::Node const & parameters
	){
	try{
	return HEJ::get_analysis(parameters);
	}
	catch(std::exception const & exc){
	std::cerr << "Failed to load analysis: " << exc.what() << '\n';
	std::exit(EXIT_FAILURE);
	}
	}

	void rescale_weights(HEJ::Event & ev, double factor) {
	ev.central().weight *= factor;
	for(auto & var: ev.variations()){
	var.weight *= factor;
	}
	}

	int main(int argn, char** argv) {
	using namespace std::string_literals;
	if (argn < 2) {
	std::cerr << "\n# Usage:\n.FOgen config_file\n";
	return EXIT_FAILURE;
	}
	std::cout << banner;
	std::cout << "Version " << HEJFOG::Version::String()
	<< ", revision " << HEJFOG::Version::revision() << std::endl;
	fastjet::ClusterSequence::print_banner();
	using clock = std::chrono::system_clock;

	const auto start_time = clock::now();

	// read configuration
	auto config = load_config(argv[1]);

	std::unique_ptr<HEJ::Analysis> analysis = get_analysis(
	config.analysis_parameters
	);
	assert(analysis != nullptr);

	auto ran = HEJ::make_RNG(config.rng.name, config.rng.seed);
	assert(ran != nullptr);

	HEJ::ScaleGenerator scale_gen{
	config.scales.base,
	config.scales.factors,
	config.scales.max_ratio
	};

	HEJFOG::EventGenerator generator{
	config.process,
	config.beam,
	std::move(scale_gen),
	config.jets,
	config.pdf_id,
	config.subleading_fraction,
	config.subleading_channels,
	config.particles_properties,
	config.Higgs_coupling,
	*ran
	};

	LHEF::HEPRUP heprup;
	heprup.IDBMUP=std::pair<long,long>(config.beam.particles[0], config.beam.particles[1]);
	heprup.EBMUP=std::make_pair(config.beam.energy, config.beam.energy);
	heprup.PDFGUP=std::make_pair(0,0);
	heprup.PDFSUP=std::make_pair(config.pdf_id,config.pdf_id);
	heprup.NPRUP=1;
	heprup.XSECUP=std::vector<double>(1.);
	heprup.XERRUP=std::vector<double>(1.);
	heprup.LPRUP=std::vector<int>{1};
	heprup.generators.emplace_back(LHEF::XMLTag{});
	heprup.generators.back().name = HEJFOG::Version::package_name();
	heprup.generators.back().version = HEJFOG::Version::String();

	HEJ::CombinedEventWriter writer{config.output, heprup};

	HEJ::optional<HEJFOG::Unweighter> unweighter{};
	std::map<HEJFOG::Status, int> status_counter;

	std::vector<HEJ::Event> events;
	int trials = 0;
	// warm-up phase to train unweighter
	if(config.unweight) {
	std::cout << "Calibrating unweighting ...\n";
	const auto warmup_start = clock::now();
	const size_t warmup_events = config.unweight->sample_size;
	HEJ::ProgressBar<size_t> warmup_progress{std::cout, warmup_events};
	for(; events.size() < warmup_events; ++trials){
	auto ev = generator.gen_event();
	++status_counter[generator.status()];
	if(generator.status() == HEJFOG::good && analysis->pass_cuts(ev, ev)) {
	events.emplace_back(std::move(ev));
	++warmup_progress;
	}
	}
	std::cout << std::endl;
	unweighter = HEJFOG::Unweighter{
	begin(events), end(events), config.unweight->max_dev, *ran,
	config.jets.peak_pt?(*config.jets.peak_pt):0.
	};
	std::vector<HEJ::Event> unweighted_events;
	for(auto && ev: events) {
	auto unweighted = unweighter->unweight(std::move(ev));
	if(unweighted) {
	unweighted_events.emplace_back(std::move(*unweighted));
	}
	}
	events = std::move(unweighted_events);
	if(events.empty()) {
	std::cerr <<
	"Failed to generate events. Please increase \"unweight: sample size\""
	" or reduce \"unweight: max deviation\"\n";
	return EXIT_FAILURE;
	}
	const auto warmup_end = clock::now();
	const double completion = static_cast<double>(events.size())/config.events;
	const std::chrono::duration<double> remaining_time =
	(warmup_end- warmup_start)*(1./completion - 1);
	const auto finish = clock::to_time_t(
	std::chrono::time_point_cast<std::chrono::seconds>(warmup_end + remaining_time)
	);
	std::cout
	<< "Generated " << events.size() << "/" << config.events << " events ("
	<< static_cast<int>(std::round(100*completion)) << "%)\n"
	<< "Estimated remaining generation time: "
	<< remaining_time.count() << " seconds ("
	<< std::put_time(std::localtime(&finish), "%c") << ")\n\n";
	}

	HEJ::ProgressBar<long long> progress{std::cout, config.events};
	progress.increment(events.size());
	events.reserve(config.events);
	for(; events.size() < static_cast<size_t>(config.events); ++trials){
	auto ev = generator.gen_event();
	++status_counter[generator.status()];
	if(generator.status() == HEJFOG::good && analysis->pass_cuts(ev, ev)) {
	if(unweighter) {
	auto unweighted = unweighter->unweight(std::move(ev));
	if(! unweighted) continue;
	ev = std::move(*unweighted);
	}
	events.emplace_back(std::move(ev));
	++progress;
	}
	}
	std::cout << std::endl;

	HEJFOG::CrossSectionAccumulator xs;
	for(auto & ev: events){
	rescale_weights(ev, invGeV2_to_pb/trials);
	analysis->fill(ev, ev);
	writer.write(ev);
	xs.fill(ev);
	}
	analysis->finalise();

	const std::chrono::duration<double> run_time = (clock::now() - start_time);
	std::cout << "\nTask Runtime: " << run_time.count() << " seconds.\n\n";

	std::cout.precision(10);
	std::cout.setf(std::ios::fixed);
	std::cout
	<< " " << std::left << std::setw(20)
	<< "Cross section: " << xs.total().value
	<< " +- " << std::sqrt(xs.total().error) << " (pb)\n";
	for(auto const & xs_type: xs) {
	std::cout
	<< " " << std::left << std::setw(20)
	<< (HEJ::event_type::names[xs_type.first] + ": "s)
	<< xs_type.second.value << " +- "
	<< std::sqrt(xs_type.second.error) << " (pb)\n";
	}

	std::cout << '\n';
	for(auto && entry: status_counter){
	const double fraction = static_cast<double>(entry.second)/trials;
	const int percent = std::round(100*fraction);
	std::cout << "status "
	<< std::left << std::setw(16) << (to_string(entry.first) + ":")
	<< " [";
	for(int i = 0; i < percent/2; ++i) std::cout << '#';
	for(int i = percent/2; i < 50; ++i) std::cout << ' ';
	std::cout << "] " << percent << "%\n";
	}

	}
	diff --git a/FixedOrderGen/t/h_2j_decay.cc b/FixedOrderGen/t/h_2j_decay.cc
	index 6ecc37c..f6a95f3 100644
	--- a/FixedOrderGen/t/h_2j_decay.cc
	+++ b/FixedOrderGen/t/h_2j_decay.cc
	@@ -1,84 +1,85 @@
	#ifdef NDEBUG
	#undef NDEBUG
	#endif

	#include <algorithm>
	#include <cmath>
	#include <cassert>
	#include <iostream>

	#include "config.hh"
	#include "EventGenerator.hh"
	-#include "HEJ/Ranlux64.hh"

	+#include "HEJ/Ranlux64.hh"
	#include "HEJ/PDF.hh"
	#include "HEJ/MatrixElement.hh"
	#include "HEJ/utility.hh"
	+#include "HEJ/Particle.hh"

	using namespace HEJFOG;

	bool pass_dR_cut(
	std::vector<fastjet::PseudoJet> const & jets,
	std::vector<HEJ::Particle> const & photons
	){
	constexpr double delta_R_min = 0.7;
	for(auto const & jet: jets){
	for(auto const & photon: photons){
	if(jet.delta_R(photon.p) < delta_R_min) return false;
	}
	}
	return true;
	}

	int main(){
	constexpr double invGeV2_to_pb = 389379292.;
	constexpr double xs_ref = 0.00429198; // +- 1.0488e-05
	//calculated with HEJ revision 9570e3809613272ac4b8bf3236279ba23cf64d20

	auto config = load_config("config_h_2j_decay.yml");

	HEJ::Ranlux64 ran{};
	HEJFOG::EventGenerator generator{
	config.process,
	config.beam,
	HEJ::ScaleGenerator{
	config.scales.base,
	config.scales.factors,
	config.scales.max_ratio
	},
	config.jets,
	config.pdf_id,
	config.subleading_fraction,
	config.subleading_channels,
	config.particles_properties,
	config.Higgs_coupling,
	ran
	};

	double xs = 0., xs_err = 0.;
	for (int trials = 0; trials < config.events; ++trials){
	auto ev = generator.gen_event();
	if(generator.status() != good) continue;
	assert(ev.decays().size() == 1);
	const auto decay = begin(ev.decays());
	assert(ev.outgoing().size() > decay->first);
	const auto & the_Higgs = ev.outgoing()[decay->first];
	assert(the_Higgs.type == HEJ::pid::Higgs);
	assert(decay->second.size() == 2);
	auto const & gamma = decay->second;
	assert(gamma[0].type == HEJ::pid::photon);
	assert(gamma[1].type == HEJ::pid::photon);
	assert(HEJ::nearby_ep(gamma[0].p + gamma[1].p, the_Higgs.p, 1e-6));
	if(!pass_dR_cut(ev.jets(), gamma)) continue;
	ev.central().weight *= invGeV2_to_pb;
	ev.central().weight /= config.events;

	xs += ev.central().weight;
	xs_err += ev.central().weight*ev.central().weight;
	}
	xs_err = std::sqrt(xs_err);
	std::cout << xs_ref << " ~ " << xs << " +- " << xs_err << std::endl;

	assert(std::abs(xs - xs_ref) < 3*xs_err);
	assert(xs_err < 0.012*xs);
	}
	diff --git a/include/HEJ/Event.hh b/include/HEJ/Event.hh
	index 51f9f50..1aea0f6 100644
	--- a/include/HEJ/Event.hh
	+++ b/include/HEJ/Event.hh
	@@ -1,186 +1,189 @@
	/** \file
	* \brief Declares the Event class and helpers
	*
	*/

	#pragma once

	#include <string>
	#include <memory>
	#include <unordered_map>

	-#include "HEJ/utility.hh"
	#include "HEJ/event_types.hh"
	+#include "HEJ/Particle.hh"
	+#include "HEJ/utility.hh"
	+
	#include "LHEF/LHEF.h"
	+
	#include "fastjet/JetDefinition.hh"
	#include "fastjet/ClusterSequence.hh"

	namespace HEJ{


	struct ParameterDescription;

	//! Event parameters
	struct EventParameters{
	double mur; /*< Value of the Renormalisation Scale /
	double muf; /*< Value of the Factorisation Scale /
	double weight; /*< Event Weight /
	//! Optional description
	std::shared_ptr<ParameterDescription> description = nullptr;
	};

	//! Description of event parameters
	struct ParameterDescription {
	//! Name of central scale choice (e.g. "H_T/2")
	std::string scale_name;
	//! Actual renormalisation scale divided by central scale
	double mur_factor;
	//! Actual factorisation scale divided by central scale
	double muf_factor;

	ParameterDescription() = default;
	ParameterDescription(
	std::string scale_name, double mur_factor, double muf_factor
	):
	scale_name{scale_name}, mur_factor{mur_factor}, muf_factor{muf_factor}
	{};
	};

	//! An event before jet clustering
	struct UnclusteredEvent{
	//! Default Constructor
	UnclusteredEvent() = default;
	//! Constructor from LesHouches event information
	UnclusteredEvent(LHEF::HEPEUP const & hepeup);

	std::array<Particle, 2> incoming; /*< Incoming Particles /
	std::vector<Particle> outgoing; /*< Outgoing Particles /
	//! Particle decays in the format {outgoing index, decay products}
	std::unordered_map<size_t, std::vector<Particle>> decays;
	//! Central parameter (e.g. scale) choice
	EventParameters central;
	std::vector<EventParameters> variations; /*< For parameter variation /
	};

	/** An event with clustered jets
	*
	* This is the main HEJ 2 event class.
	* It contains kinematic information including jet clustering,
	* parameter (e.g. scale) settings and the event weight.
	*/
	class Event{
	public:
	//! Default Event Constructor
	Event() = default;
	//! Event Constructor adding jet clustering to an unclustered event
	Event(
	UnclusteredEvent ev,
	fastjet::JetDefinition const & jet_def, double min_jet_pt
	);

	//! The jets formed by the outgoing partons
	std::vector<fastjet::PseudoJet> jets() const;

	//! The corresponding event before jet clustering
	UnclusteredEvent const & unclustered() const {
	return ev_;
	}

	//! Central parameter choice
	EventParameters const & central() const{
	return ev_.central;
	}

	//! Central parameter choice
	EventParameters & central(){
	return ev_.central;
	}

	//! Incoming particles
	std::array<Particle, 2> const & incoming() const{
	return ev_.incoming;
	}

	//! Outgoing particles
	std::vector<Particle> const & outgoing() const{
	return ev_.outgoing;
	}

	//! Particle decays
	/**
	* The key in the returned map corresponds to the index in the
	* vector returned by outgoing()
	*/
	std::unordered_map<size_t, std::vector<Particle>> const & decays() const{
	return ev_.decays;
	}

	//! Parameter (scale) variations
	std::vector<EventParameters> const & variations() const{
	return ev_.variations;
	}

	//! Parameter (scale) variations
	std::vector<EventParameters> & variations(){
	return ev_.variations;
	}

	//! Parameter (scale) variation
	/**
	* @param i Index of the requested variation
	*/
	EventParameters const & variations(size_t i) const{
	return ev_.variations[i];
	}

	//! Parameter (scale) variation
	/**
	* @param i Index of the requested variation
	*/
	EventParameters & variations(size_t i){
	return ev_.variations[i];
	}

	//! Indices of the jets the outgoing partons belong to
	/**
	* @param jets Jets to be tested
	* @returns A vector containing, for each outgoing parton,
	* the index in the vector of jets the considered parton
	* belongs to. If the parton is not inside any of the
	* passed jets, the corresponding index is set to -1.
	*/
	std::vector<int> particle_jet_indices(
	std::vector<fastjet::PseudoJet> const & jets
	) const{
	return cs_.particle_jet_indices(jets);
	}

	//! Jet definition used for clustering
	fastjet::JetDefinition const & jet_def() const{
	return cs_.jet_def();
	}

	//! Minimum jet transverse momentum
	double min_jet_pt() const{
	return min_jet_pt_;
	}

	//! Event type
	event_type::EventType type() const{
	return type_;
	}

	private:
	UnclusteredEvent ev_;
	fastjet::ClusterSequence cs_;
	double min_jet_pt_;
	event_type::EventType type_;
	};

	//! Square of the partonic centre-of-mass energy \f$\hat{s}\f$
	double shat(Event const & ev);

	//! Convert an event to a LHEF::HEPEUP
	LHEF::HEPEUP to_HEPEUP(Event const & event, LHEF::HEPRUP *);

	}
	diff --git a/include/HEJ/EventReweighter.hh b/include/HEJ/EventReweighter.hh
	index 8e33d2d..b21c00f 100644
	--- a/include/HEJ/EventReweighter.hh
	+++ b/include/HEJ/EventReweighter.hh
	@@ -1,181 +1,181 @@
	/** \file
	* \brief Declares the EventReweighter class
	*
	* EventReweighter is the main class used within HEJ 2. It reweights the
	* resummation events.
	*/
	#pragma once

	#include "fastjet/PseudoJet.hh"
	#include "fastjet/ClusterSequence.hh"

	#include "LHEF/LHEF.h"

	#include "HEJ/config.hh"
	#include "HEJ/PDF.hh"
	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/Event.hh"
	#include "HEJ/event_types.hh"
	#include "HEJ/PhaseSpacePoint.hh"
	#include "HEJ/MatrixElement.hh"
	#include "HEJ/RNG.hh"

	namespace HEJ{

	//! Beam parameters
	/**
	* Currently, only symmetric beams are supported,
	* so there is a single beam energy.
	*/
	struct Beam{
	double E; /*< Beam energy /
	std::array<ParticleID, 2> type; /*< Beam particles /
	};

	//! Main class for reweighting events in HEJ.
	class EventReweighter{
	using EventType = event_type::EventType;
	public:

	EventReweighter(
	Beam beam, /*< Beam Energy /
	int pdf_id, /*< PDF ID /
	ScaleGenerator scale_gen, /*< Scale settings /
	EventReweighterConfig conf, /*< Configuration parameters /
	HEJ::RNG & ran /*< Random number generator /
	);

	EventReweighter(
	LHEF::HEPRUP const & heprup, /*< LHEF event header /
	ScaleGenerator scale_gen, /*< Scale settings /
	EventReweighterConfig conf, /*< Configuration parameters /
	HEJ::RNG & ran /*< Random number generator /
	);

	//! Get the used pdf
	PDF const & pdf() const;


	//! Generate resummation events for a given fixed-order event
	/**
	* @param ev Fixed-order event corresponding
	* to the resummation events
	* @param num_events Number of trial resummation configurations.
	* @returns A vector of resummation events.
	*
	* The result vector depends on the type of the input event and the
	* treatment of different types as specified in the constructor:
	*
	* \ref reweight The result vector contains between
	* 0 and num_events resummation events.
	*
	* \ref keep If the input event passes the resummation jet cuts
	* the result vector contains one event. Otherwise it is empty.
	*
	* \ref discard The result vector is empty
	*/
	std::vector<Event> reweight(
	Event const & ev,
	int num_events
	);

	private:

	template<typename... T>
	PDF const & pdf(T&& ...);

	/** \internal
	* \brief main generation/reweighting function:
	* generate phase space points and divide out Born factors
	*/
	std::vector<Event> gen_res_events(
	Event const & ev, int num_events
	);
	std::vector<Event> rescale(
	Event const & Born_ev, std::vector<Event> events
	) const;

	/** \internal
	* \brief Do the Jets pass the resummation Cuts?
	*
	* @param ev Event in Question
	* @returns 0 or 1 depending on if ev passes Jet Cuts
	*/
	bool jets_pass_resummation_cuts(Event const & ev) const;

	/** \internal
	* \brief pdf_factors Function
	*
	* @param ev Event in Question
	* @returns EventFactor due to PDFs
	*
	* Calculates the Central value and the variation due
	* to the PDF choice made.
	*/
	Weights pdf_factors(Event const & ev) const;

	/** \internal
	* \brief matrix_elements Function
	*
	* @param ev Event in question
	* @returns EventFactor due to MatrixElements
	*
	* Calculates the Central value and the variation due
	* to the Matrix Element.
	*/
	Weights matrix_elements(Event const & ev) const;

	/** \internal
	* \brief Scale-dependent part of fixed-order matrix element
	*
	* @param ev Event in question
	* @returns EventFactor scale variation due to FO-ME.
	*
	* This is only called to compute the scale variation for events where
	* we don't do resummation (e.g. non-FKL).
	* Since at tree level the scale dependence is just due to alpha_s,
	* it is enough to return the alpha_s(mur) factors in the matrix element.
	* The rest drops out in the ratio of (output event ME)/(input event ME),
	* so we never have to compute it.
	*/
	Weights fixed_order_scale_ME(Event const & ev) const;

	/** \internal
	* \brief Computes the tree level matrix element
	*
	* @param ev Event in Question
	* @returns HEJ approximation to Tree level Matrix Element
	*
	* This computes the HEJ approximation to the tree level FO
	* Matrix element which is used within the LO weighting process.
	*/
	double tree_matrix_element(Event const & ev) const;


	//! \internal General parameters
	EventReweighterConfig param_;

	//! \internal Beam energy
	double E_beam_;

	//! \internal PDF
	PDF pdf_;

	//! \internal Object to calculate the square of the matrix element
	MatrixElement MEt2_;
	//! \internal Object to calculate event renormalisation and factorisation scales
	ScaleGenerator scale_gen_;
	/** \internal random number generator
	*
	* \note We use a reference_wrapper so that EventReweighter objects can
	* still be copied (which would be impossible with a reference).
	*/
	std::reference_wrapper<HEJ::RNG> ran_;
	};

	template<typename... T>
	PDF const & EventReweighter::pdf(T&&... t){
	return pdf_ = PDF{std::forward<T>(t)...};
	}

	}
	diff --git a/include/HEJ/JetSplitter.hh b/include/HEJ/JetSplitter.hh
	index b361dde..c3092f2 100644
	--- a/include/HEJ/JetSplitter.hh
	+++ b/include/HEJ/JetSplitter.hh
	@@ -1,57 +1,63 @@
	/**
	* \file
	* \brief Declaration of the JetSplitter class
	*/

	#pragma once

	-#include "HEJ/utility.hh"
	+#include <vector>
	+
	+#include "fastjet/PseudoJet.hh"
	+#include "fastjet/ClusterSequence.hh"
	+
	+// #include "HEJ/utility.hh"
	#include "HEJ/RNG.hh"

	+
	namespace HEJ {
	//! Class to split jets into their constituents
	class JetSplitter {

	public:
	struct SplitResult {
	std::vector<fastjet::PseudoJet> constituents;
	double weight;
	};

	//! Constructor
	/**
	* @param jet_def Jet definition
	* @param min_pt Minimum jet transverse momentum
	* @param ran Random number generator
	*/
	JetSplitter(
	fastjet::JetDefinition jet_def, double min_pt,
	HEJ::RNG & ran
	):
	R_{jet_def.R()},
	min_jet_pt_{min_pt},
	jet_def_{jet_def},
	ran_{ran}
	{}

	//! Split a get into constituents
	/**
	* @param j2split Jet to be split
	* @param ncons Number of constituents
	* @returns The constituent momenta
	* together with the associated weight
	*/
	SplitResult split(fastjet::PseudoJet const & j2split, int ncons) const;

	//! Maximum distance of constituents to jet axis
	static constexpr double R_factor = 5./3.;
	private:
	SplitResult Split2(fastjet::PseudoJet const & j2split) const;
	double sample_distance_2p(double & wt) const;

	double R_;
	double min_jet_pt_;
	fastjet::JetDefinition jet_def_;
	std::reference_wrapper<HEJ::RNG> ran_;
	};
	}
	diff --git a/include/HEJ/MatrixElement.hh b/include/HEJ/MatrixElement.hh
	index 0193736..84dd3a8 100644
	--- a/include/HEJ/MatrixElement.hh
	+++ b/include/HEJ/MatrixElement.hh
	@@ -1,145 +1,146 @@
	/** \file
	* \brief Contains the MatrixElement Class
	*/
	#pragma once

	#include <functional>

	#include "HEJ/config.hh"
	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/HiggsCouplingSettings.hh"
	#include "HEJ/Weights.hh"

	#include "CLHEP/Vector/LorentzVector.h"


	namespace HEJ{
	class Event;
	+ class Particle;

	//! Class to calculate the squares of matrix elements
	class MatrixElement{
	public:
	/** \brief MatrixElement Constructor
	* @param alpha_s Function taking the renormalisation scale
	* and returning the strong coupling constant
	* @param conf General matrix element settings
	*/
	MatrixElement(
	std::function<double (double)> alpha_s,
	MatrixElementConfig conf
	);

	/**
	* \brief squares of regulated HEJ matrix elements
	* @param event The event for which to calculate matrix elements
	* @returns The squares of HEJ matrix elements including virtual corrections
	*
	* cf. eq. (22) in \cite Andersen:2011hs
	*
	* \internal Relation to standard HEJ Met2: MatrixElement = Met2shat^2/(pdftapdftb)
	*/
	Weights operator()(Event const & event) const;

	//! Squares of HEJ tree-level matrix elements
	/**
	* @param event The event for which to calculate matrix elements
	* @returns The squares of HEJ matrix elements without virtual corrections
	*
	* cf. eq. (22) in \cite Andersen:2011hs
	*/
	Weights tree(Event const & event) const;

	/**
	* \brief Virtual corrections to matrix element squares
	* @param event The event for which to calculate matrix elements
	* @returns The virtual corrections to the squares of the matrix elements
	*
	* The all order virtual corrections to LL in the MRK limit is
	* given by replacing 1/t in the scattering amplitude according to the
	* lipatov ansatz.
	*
	* cf. second-to-last line of eq. (22) in \cite Andersen:2011hs
	* note that indices are off by one, i.e. out[0].p corresponds to p_1
	*/
	Weights virtual_corrections(Event const & event) const;

	private:

	Weights tree_param(
	Event const & event
	) const;

	double tree_kin(Event const & event) const;

	double tree_param(
	Event const & event,
	double mur
	) const;

	double virtual_corrections(
	Event const & event,
	double mur
	) const;

	//! \internal cf. last line of eq. (22) in \cite Andersen:2011hs
	double omega0(
	double alpha_s, double mur,
	fastjet::PseudoJet const & q_j, double lambda
	) const;

	double tree_kin_jets(
	Event const & ev
	) const;
	double tree_kin_Higgs(
	Event const & ev
	) const;
	double tree_kin_Higgs_first(
	Event const & ev
	) const;
	double tree_kin_Higgs_last(
	Event const & ev
	) const;

	/**
	* \internal
	* \brief Higgs inbetween extremal partons.
	*
	* Note that in the case of unordered emission, the Higgs is always
	* treated as if in between the extremal (FKL) partons, even if its
	* rapidity is outside the extremal parton rapidities
	*/
	double tree_kin_Higgs_between(
	Event const & ev
	) const;


	double tree_param_partons(
	double alpha_s, double mur,
	std::vector<Particle> const & partons
	) const;


	std::vector<int> in_extremal_jet_indices(
	std::vector<fastjet::PseudoJet> const & partons
	) const;


	std::vector<Particle> tag_extremal_jet_partons(
	Event const & ev
	) const;

	double MH2_forwardH(
	CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in,
	pid::ParticleID type2,
	CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in,
	CLHEP::HepLorentzVector pH,
	double t1, double t2
	) const;

	std::function<double (double)> alpha_s_;

	MatrixElementConfig param_;
	};


	}
	diff --git a/include/HEJ/PDF.hh b/include/HEJ/PDF.hh
	index 2772770..79909d6 100644
	--- a/include/HEJ/PDF.hh
	+++ b/include/HEJ/PDF.hh
	@@ -1,73 +1,73 @@
	/** \file
	*
	* \brief Contains all the necessary classes and functions for interaction with PDFs.
	*/

	#pragma once

	#include <array>

	#include "LHAPDF/LHAPDF.h"
	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/PDG_codes.hh"

	namespace HEJ{

	//! Class for interaction with a PDF set
	class PDF {
	public:
	/**
	* \brief PDF Constructor
	* @param id Particle ID according to PDG
	* @param beam1 Particle ID of particle in beam 1
	* @param beam2 Particle ID of particle in beam 2
	*/
	PDF(int id, ParticleID beam1, ParticleID beam2);

	/**
	* \brief Calculate the pdf value x*f(x, q)
	* @param beam_idx Beam number (0 or 1)
	* @param x Momentum fraction
	* @param q Energy scale
	* @param id PDG particle id
	* @returns x*f(x, q)
	*
	* Returns 0 if x or q are outside the range covered by the PDF set
	*/
	double pdfpt(size_t beam_idx, double x, double q, ParticleID id) const;

	/**
	* \brief Value of the strong coupling \f$\alpha_s(q)\f$ at the given scale
	* @param q Renormalisation scale
	* @returns Value of the strong coupling constant
	*/
	double Halphas(double q) const;

	//! Check if the energy scale is within the range covered by the PDF set
	/**
	* @param q Energy Scale
	* @returns true if q is within the covered range, false otherwise
	*/
	bool inRangeQ(double q) const;

	//! Check if the momentum fraction is within the range covered by the PDF set
	/**
	* @param x Momentum Fraction
	* @returns true if x is within the covered range, false otherwise
	*/
	bool inRangeX(double x) const;

	#if defined LHAPDF_MAJOR_VERSION && LHAPDF_MAJOR_VERSION == 6
	//! PDF id of the current set
	int id() const;
	#endif

	private:

	#if defined LHAPDF_MAJOR_VERSION && LHAPDF_MAJOR_VERSION == 6
	std::unique_ptr<LHAPDF::PDF> pdf;
	#endif

	std::array<int, 2> beamtype;
	};
	}
	diff --git a/include/HEJ/utility.hh b/include/HEJ/Particle.hh
	similarity index 51%
	copy from include/HEJ/utility.hh
	copy to include/HEJ/Particle.hh
	index f7b1262..c6c3f94 100644
	--- a/include/HEJ/utility.hh
	+++ b/include/HEJ/Particle.hh
	@@ -1,206 +1,116 @@
	/**
	- * \file
	- * \brief Contains various utilities
	+ * \file Particle.hh
	+ * \brief Contains the particle struct
	*/

	#pragma once

	-#include <algorithm>
	-#include <cassert>
	-
	-#include <boost/core/demangle.hpp>
	-
	// FastJet Includes
	#include "fastjet/PseudoJet.hh"
	-#include "fastjet/ClusterSequence.hh"
	+// #include "fastjet/ClusterSequence.hh"

	#include "HEJ/PDG_codes.hh"

	-namespace HEJ{
	+namespace HEJ {
	+
	//! Class representing a particle
	struct Particle {
	//! particle type
	ParticleID type;
	//! particle momentum
	fastjet::PseudoJet p;

	//! get rapidity
	double rapidity() const{
	return p.rapidity();
	}
	//! get transverse momentum
	double perp() const{
	return p.perp();
	}
	//! get momentum in x direction
	double px() const{
	return p.px();
	}
	//! get momentum in y direction
	double py() const{
	return p.py();
	}
	//! get momentum in z direction
	double pz() const{
	return p.pz();
	}
	//! get energy
	double E() const{
	return p.E();
	}
	//! get mass
	double m() const{
	return p.m();
	}
	};

	//! Functor to compare rapidities
	/**
	* This can be used whenever a rapidity comparison function is needed,
	* for example in many standard library functions.
	*
	* @see pz_less
	*/
	struct rapidity_less{
	template<class FourVector>
	bool operator()(FourVector const & p1, FourVector const & p2){
	return p1.rapidity() < p2.rapidity();
	}
	};

	//! Functor to compare momenta in z direction
	/**
	* This can be used whenever a pz comparison function is needed,
	* for example in many standard library functions.
	*
	* @see rapidity_less
	*/
	struct pz_less{
	template<class FourVector>
	bool operator()(FourVector const & p1, FourVector const & p2){
	return p1.pz() < p2.pz();
	}
	};


	//! Convert a vector of Particles to a vector of particle momenta
	inline
	std::vector<fastjet::PseudoJet> to_PseudoJet(
	std::vector<Particle> const & v
	){
	std::vector<fastjet::PseudoJet> result;
	for(auto && sp: v) result.emplace_back(sp.p);
	return result;
	}

	//! Check if a particle is a parton, i.e. quark, antiquark, or gluon
	inline
	bool is_parton(Particle const & p){
	return is_parton(p.type);
	}

	//! Check if a particle is a photon, W, Z, or Higgs boson
	inline bool is_AWZH_boson(Particle const & particle){
	return is_AWZH_boson(particle.type);
	}

	//! Extract all partons from a vector of particles
	inline
	std::vector<Particle> filter_partons(
	std::vector<Particle> const & v
	){
	std::vector<Particle> result;
	result.reserve(v.size());
	std::copy_if(
	begin(v), end(v), std::back_inserter(result),
	[](Particle const & p){ return is_parton(p); }
	);
	return result;
	}
	-
	- //! Create a std::unique_ptr to a T object
	- /**
	- * For non-array types this works like std::make_unique,
	- * which is not available under C++11
	- */
	- template<class T, class... Args>
	- std::unique_ptr<T> make_unique(Args&&... a){
	- return std::unique_ptr<T>{new T{std::forward<Args>(a)...}};
	- }
	-
	- //! Create an array containing the passed arguments
	- template<typename T, typename... U>
	- constexpr
	- std::array<T, 1 + sizeof...(U)> make_array(T t, U&&... rest){
	- return {{t, std::forward<U>(rest)...}};
	- }
	-
	-
	- inline
	- std::string join(
	- std::string const & /* delim */
	- ){
	- return "";
	- }
	-
	- inline
	- std::string join(
	- std::string const & /* delim */, std::string const & str
	- ){
	- return str;
	- }
	-
	- //! Join strings with a delimiter
	- /**
	- * @param delim Delimiter to be put between consecutive strings
	- * @param first First string
	- * @param second Second string
	- * @param rest Remaining strings
	- */
	- template<typename... Strings>
	- std::string join(
	- std::string const & delim,
	- std::string const & first, std::string const & second,
	- Strings&&... rest
	- ){
	- return join(delim, first + delim + second, std::forward<Strings>(rest)...);
	- }
	-
	- //! Return the name of the argument's type
	- template<typename T>
	- std::string type_string(T&&){
	- return boost::core::demangle(typeid(T).name());
	- }
	-
	- //! Eliminate compiler warnings for unused variables
	- template<typename... T>
	- constexpr void ignore(T&&...) {}
	-
	- //! Check whether two doubles are closer than ep > 0 to each other
	- inline
	- bool nearby_ep(double a, double b, double ep){
	- assert(ep > 0);
	- return std::abs(a-b) < ep;
	- }
	-
	- //! Check whether all components of two PseudoJets are closer than ep to each other
	- inline
	- bool nearby_ep(
	- fastjet::PseudoJet const & pa, fastjet::PseudoJet const & pb,
	- double ep
	- ){
	- assert(ep > 0);
	- for(size_t i = 0; i < 4; ++i){
	- if(!nearby_ep(pa[i], pb[i], ep)) return false;
	- }
	- return true;
	- }
	-
	- inline
	- bool nearby(
	- fastjet::PseudoJet const & pa, fastjet::PseudoJet const & pb, double const norm = 1.
	- ){
	- return nearby_ep(pa, pb, 1e-7*norm);
	- }
	-
	}
	diff --git a/include/HEJ/PhaseSpacePoint.hh b/include/HEJ/PhaseSpacePoint.hh
	index dbfc131..ac74749 100644
	--- a/include/HEJ/PhaseSpacePoint.hh
	+++ b/include/HEJ/PhaseSpacePoint.hh
	@@ -1,148 +1,149 @@
	/** \file
	* \brief Contains the PhaseSpacePoint Class
	*/

	#pragma once

	#include <vector>

	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/config.hh"
	#include "HEJ/Event.hh"
	#include "HEJ/JetSplitter.hh"
	+#include "HEJ/Particle.hh"
	#include "HEJ/RNG.hh"

	namespace HEJ{

	//! A point in resummation phase space
	class PhaseSpacePoint{
	public:
	//! Default PhaseSpacePoint Constructor
	PhaseSpacePoint() = default;

	//! PhaseSpacePoint Constructor
	/**
	* @param ev Clustered Jet Event
	* @param conf Configuration parameters
	* @param ran Random number generator
	*/
	PhaseSpacePoint(
	Event const & ev,
	PhaseSpacePointConfig conf,
	HEJ::RNG & ran
	);

	//! Get phase space point weight
	double weight() const{
	return weight_;
	}

	//! Access incoming particles
	std::array<Particle, 2> const & incoming() const{
	return incoming_;
	}

	//! Access outgoing particles
	std::vector<Particle> const & outgoing() const{
	return outgoing_;
	}


	//! Particle decays
	/**
	* The key in the returned map corresponds to the index in the
	* vector returned by outgoing()
	*/
	std::unordered_map<size_t, std::vector<Particle>> const & decays() const{
	return decays_;
	}

	static constexpr int ng_max = 1000; //< maximum number of extra gluons

	private:

	std::vector<fastjet::PseudoJet> cluster_jets(
	std::vector<fastjet::PseudoJet> const & partons
	) const;
	bool pass_resummation_cuts(
	std::vector<fastjet::PseudoJet> const & jets
	) const;
	bool pass_extremal_cuts(
	fastjet::PseudoJet const & ext_parton,
	fastjet::PseudoJet const & jet
	) const;
	int sample_ng(std::vector<fastjet::PseudoJet> const & Born_jets);
	int sample_ng_jets(int ng, std::vector<fastjet::PseudoJet> const & Born_jets);
	double probability_in_jet(
	std::vector<fastjet::PseudoJet> const & Born_jets
	) const;
	std::vector<fastjet::PseudoJet> gen_non_jet(
	int ng_non_jet,
	double ptmin, double ptmax
	);
	void rescale_rapidities(
	std::vector<fastjet::PseudoJet> & partons,
	double ymin, double ymax
	);
	std::vector<fastjet::PseudoJet> reshuffle(
	std::vector<fastjet::PseudoJet> const & Born_jets,
	fastjet::PseudoJet const & q
	);
	bool jets_ok(
	std::vector<fastjet::PseudoJet> const & Born_jets,
	std::vector<fastjet::PseudoJet> const & partons
	) const;
	void reconstruct_incoming(std::array<Particle, 2> const & Born_incoming);
	double phase_space_normalisation(
	int num_Born_jets,
	int num_res_partons
	) const;
	std::vector<fastjet::PseudoJet> split(
	std::vector<fastjet::PseudoJet> const & jets, int ng_jets
	);
	std::vector<int> distribute_jet_partons(
	int ng_jets, std::vector<fastjet::PseudoJet> const & jets
	);
	std::vector<fastjet::PseudoJet> split(
	std::vector<fastjet::PseudoJet> const & jets,
	std::vector<int> const & np_in_jet
	);
	bool split_preserved_jets(
	std::vector<fastjet::PseudoJet> const & jets,
	std::vector<fastjet::PseudoJet> const & jet_partons
	) const;
	template<class Particle>
	Particle const & most_backward_FKL(
	std::vector<Particle> const & partons
	) const;
	template<class Particle>
	Particle const & most_forward_FKL(
	std::vector<Particle> const & partons
	) const;
	template<class Particle>
	Particle & most_backward_FKL(std::vector<Particle> & partons) const;
	template<class Particle>
	Particle & most_forward_FKL(std::vector<Particle> & partons) const;
	bool extremal_ok(
	std::vector<fastjet::PseudoJet> const & partons
	) const;
	void copy_AWZH_boson_from(Event const & event);

	bool momentum_conserved() const;

	bool unob_, unof_;

	double weight_;

	PhaseSpacePointConfig param_;


	std::array<Particle, 2> incoming_;
	std::vector<Particle> outgoing_;
	//! \internal Particle decays in the format {outgoing index, decay products}
	std::unordered_map<size_t, std::vector<Particle>> decays_;

	std::reference_wrapper<HEJ::RNG> ran_;
	};

	}
	diff --git a/include/HEJ/utility.hh b/include/HEJ/utility.hh
	index f7b1262..74421db 100644
	--- a/include/HEJ/utility.hh
	+++ b/include/HEJ/utility.hh
	@@ -1,206 +1,103 @@
	/**
	* \file
	* \brief Contains various utilities
	*/

	#pragma once

	#include <algorithm>
	#include <cassert>
	+#include <memory>

	#include <boost/core/demangle.hpp>

	-// FastJet Includes
	#include "fastjet/PseudoJet.hh"
	-#include "fastjet/ClusterSequence.hh"
	-
	-#include "HEJ/PDG_codes.hh"

	namespace HEJ{
	- //! Class representing a particle
	- struct Particle {
	- //! particle type
	- ParticleID type;
	- //! particle momentum
	- fastjet::PseudoJet p;
	-
	- //! get rapidity
	- double rapidity() const{
	- return p.rapidity();
	- }
	- //! get transverse momentum
	- double perp() const{
	- return p.perp();
	- }
	- //! get momentum in x direction
	- double px() const{
	- return p.px();
	- }
	- //! get momentum in y direction
	- double py() const{
	- return p.py();
	- }
	- //! get momentum in z direction
	- double pz() const{
	- return p.pz();
	- }
	- //! get energy
	- double E() const{
	- return p.E();
	- }
	- //! get mass
	- double m() const{
	- return p.m();
	- }
	- };
	-
	- //! Functor to compare rapidities
	- /**
	- * This can be used whenever a rapidity comparison function is needed,
	- * for example in many standard library functions.
	- *
	- * @see pz_less
	- */
	- struct rapidity_less{
	- template<class FourVector>
	- bool operator()(FourVector const & p1, FourVector const & p2){
	- return p1.rapidity() < p2.rapidity();
	- }
	- };
	-
	- //! Functor to compare momenta in z direction
	- /**
	- * This can be used whenever a pz comparison function is needed,
	- * for example in many standard library functions.
	- *
	- * @see rapidity_less
	- */
	- struct pz_less{
	- template<class FourVector>
	- bool operator()(FourVector const & p1, FourVector const & p2){
	- return p1.pz() < p2.pz();
	- }
	- };
	-
	-
	- //! Convert a vector of Particles to a vector of particle momenta
	- inline
	- std::vector<fastjet::PseudoJet> to_PseudoJet(
	- std::vector<Particle> const & v
	- ){
	- std::vector<fastjet::PseudoJet> result;
	- for(auto && sp: v) result.emplace_back(sp.p);
	- return result;
	- }
	-
	- //! Check if a particle is a parton, i.e. quark, antiquark, or gluon
	- inline
	- bool is_parton(Particle const & p){
	- return is_parton(p.type);
	- }
	-
	- //! Check if a particle is a photon, W, Z, or Higgs boson
	- inline bool is_AWZH_boson(Particle const & particle){
	- return is_AWZH_boson(particle.type);
	- }
	-
	- //! Extract all partons from a vector of particles
	- inline
	- std::vector<Particle> filter_partons(
	- std::vector<Particle> const & v
	- ){
	- std::vector<Particle> result;
	- result.reserve(v.size());
	- std::copy_if(
	- begin(v), end(v), std::back_inserter(result),
	- [](Particle const & p){ return is_parton(p); }
	- );
	- return result;
	- }

	//! Create a std::unique_ptr to a T object
	/**
	* For non-array types this works like std::make_unique,
	* which is not available under C++11
	*/
	template<class T, class... Args>
	std::unique_ptr<T> make_unique(Args&&... a){
	return std::unique_ptr<T>{new T{std::forward<Args>(a)...}};
	}

	//! Create an array containing the passed arguments
	template<typename T, typename... U>
	constexpr
	std::array<T, 1 + sizeof...(U)> make_array(T t, U&&... rest){
	return {{t, std::forward<U>(rest)...}};
	}


	inline
	std::string join(
	std::string const & /* delim */
	){
	return "";
	}

	inline
	std::string join(
	std::string const & /* delim */, std::string const & str
	){
	return str;
	}

	//! Join strings with a delimiter
	/**
	* @param delim Delimiter to be put between consecutive strings
	* @param first First string
	* @param second Second string
	* @param rest Remaining strings
	*/
	template<typename... Strings>
	std::string join(
	std::string const & delim,
	std::string const & first, std::string const & second,
	Strings&&... rest
	){
	return join(delim, first + delim + second, std::forward<Strings>(rest)...);
	}

	//! Return the name of the argument's type
	template<typename T>
	std::string type_string(T&&){
	return boost::core::demangle(typeid(T).name());
	}

	//! Eliminate compiler warnings for unused variables
	template<typename... T>
	constexpr void ignore(T&&...) {}

	//! Check whether two doubles are closer than ep > 0 to each other
	inline
	bool nearby_ep(double a, double b, double ep){
	assert(ep > 0);
	return std::abs(a-b) < ep;
	}

	//! Check whether all components of two PseudoJets are closer than ep to each other
	inline
	bool nearby_ep(
	fastjet::PseudoJet const & pa, fastjet::PseudoJet const & pb,
	double ep
	){
	assert(ep > 0);
	for(size_t i = 0; i < 4; ++i){
	if(!nearby_ep(pa[i], pb[i], ep)) return false;
	}
	return true;
	}

	inline
	bool nearby(
	fastjet::PseudoJet const & pa, fastjet::PseudoJet const & pb, double const norm = 1.
	){
	return nearby_ep(pa, pb, 1e-7*norm);
	}

	}
	diff --git a/src/Event.cc b/src/Event.cc
	index 2449e5a..a11960b 100644
	--- a/src/Event.cc
	+++ b/src/Event.cc
	@@ -1,371 +1,371 @@
	#include "HEJ/Event.hh"

	#include <numeric>

	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"

	namespace HEJ{

	namespace{
	constexpr int status_in = -1;
	constexpr int status_decayed = 2;
	constexpr int status_out = 1;

	/// @name helper functions to determine event type
	//@{

	/**
	* \brief check if final state valid for HEJ
	*
	* check if there is at most one photon, W, H, Z in the final state
	* and all the rest are quarks or gluons
	*/
	bool final_state_ok(std::vector<Particle> const & outgoing){
	bool has_AWZH_boson = false;
	for(auto const & out: outgoing){
	if(is_AWZH_boson(out.type)){
	if(has_AWZH_boson) return false;
	has_AWZH_boson = true;
	}
	else if(! is_parton(out.type)) return false;
	}
	return true;
	}

	template<class Iterator>
	Iterator remove_AWZH(Iterator begin, Iterator end){
	return std::remove_if(
	begin, end, [](Particle const & p){return is_AWZH_boson(p);}
	);
	}

	template<class Iterator>
	bool valid_outgoing(Iterator begin, Iterator end){
	return std::distance(begin, end) >= 2
	&& std::is_sorted(begin, end, rapidity_less{})
	&& std::count_if(
	begin, end, [](Particle const & s){return is_AWZH_boson(s);}
	) < 2;
	}

	/// @note that this changes the outgoing range!
	template<class ConstIterator, class Iterator>
	bool is_FKL(
	ConstIterator begin_incoming, ConstIterator end_incoming,
	Iterator begin_outgoing, Iterator end_outgoing
	){
	assert(std::distance(begin_incoming, end_incoming) == 2);
	assert(std::distance(begin_outgoing, end_outgoing) >= 2);

	// One photon, W, H, Z in the final state is allowed.
	// Remove it for remaining tests,
	end_outgoing = remove_AWZH(begin_outgoing, end_outgoing);

	// Test if this is a standard FKL configuration.
	return
	(begin_incoming->type == begin_outgoing->type)
	&& ((end_incoming-1)->type == (end_outgoing-1)->type)
	&& std::all_of(
	begin_outgoing + 1, end_outgoing - 1,
	[](Particle const & p){ return p.type == pid::gluon; }
	);
	}

	bool is_FKL(
	std::array<Particle, 2> const & incoming,
	std::vector<Particle> outgoing
	){
	assert(std::is_sorted(begin(incoming), end(incoming), pz_less{}));
	assert(valid_outgoing(begin(outgoing), end(outgoing)));

	return is_FKL(
	begin(incoming), end(incoming),
	begin(outgoing), end(outgoing)
	);
	}

	bool has_2_jets(Event const & event){
	return event.jets().size() >= 2;
	}

	/**
	* \brief Checks whether event is unordered backwards
	* @param ev Event
	* @returns Is Event Unordered Backwards
	*
	* - Checks there is more than 3 constuents in the final state
	* - Checks there is more than 3 jets
	* - Checks the most backwards parton is a gluon
	* - Checks the most forwards jet is not a gluon
	* - Checks the rest of the event is FKL
	* - Checks the second most backwards is not a different boson
	* - Checks the unordered gluon actually forms a jet
	*/
	bool is_unordered_backward(Event const & ev){
	auto const & in = ev.incoming();
	auto const & out = ev.outgoing();
	assert(std::is_sorted(begin(in), end(in), pz_less{}));
	assert(valid_outgoing(begin(out), end(out)));

	if(out.size() < 3) return false;
	if(ev.jets().size() < 3) return false;
	if(in.front().type == pid::gluon) return false;
	if(out.front().type != pid::gluon) return false;
	// When skipping the unordered emission
	// the remainder should be a regular FKL event,
	// except that the (new) first outgoing particle must not be a A,W,Z,H.
	const auto FKL_begin = next(begin(out));
	if(is_AWZH_boson(*FKL_begin)) return false;
	if(!is_FKL(in, {FKL_begin, end(out)})) return false;
	// check that the unordered gluon forms an extra jet
	const auto jets = sorted_by_rapidity(ev.jets());
	const auto indices = ev.particle_jet_indices({jets.front()});
	return indices[0] >= 0 && indices[1] == -1;
	}

	/**
	* \brief Checks for a forward unordered gluon emission
	* @param ev Event
	* @returns Is the event a forward unordered emission
	*
	* \see is_unordered_backward
	*/
	bool is_unordered_forward(Event const & ev){
	auto const & in = ev.incoming();
	auto const & out = ev.outgoing();
	assert(std::is_sorted(begin(in), end(in), pz_less{}));
	assert(valid_outgoing(begin(out), end(out)));

	if(out.size() < 3) return false;
	if(ev.jets().size() < 3) return false;
	if(in.back().type == pid::gluon) return false;
	if(out.back().type != pid::gluon) return false;
	// When skipping the unordered emission
	// the remainder should be a regular FKL event,
	// except that the (new) last outgoing particle must not be a A,W,Z,H.
	const auto FKL_end = prev(end(out));
	if(is_AWZH_boson(*prev(FKL_end))) return false;
	if(!is_FKL(in, {begin(out), FKL_end})) return false;
	// check that the unordered gluon forms an extra jet
	const auto jets = sorted_by_rapidity(ev.jets());
	const auto indices = ev.particle_jet_indices({jets.back()});
	return indices.back() >= 0 && indices[indices.size()-2] == -1;
	}

	using event_type::EventType;

	EventType classify(Event const & ev){
	if(! final_state_ok(ev.outgoing())) return EventType::bad_final_state;
	if(! has_2_jets(ev)) return EventType::no_2_jets;
	if(is_FKL(ev.incoming(), ev.outgoing())) return EventType::FKL;
	if(is_unordered_backward(ev)){
	return EventType::unordered_backward;
	}
	if(is_unordered_forward(ev)){
	return EventType::unordered_forward;
	}
	return EventType::nonHEJ;
	}
	//@}

	Particle extract_particle(LHEF::HEPEUP const & hepeup, int i){
	return Particle{
	static_cast<ParticleID>(hepeup.IDUP[i]),
	fastjet::PseudoJet{
	hepeup.PUP[i][0], hepeup.PUP[i][1],
	hepeup.PUP[i][2], hepeup.PUP[i][3]
	}
	};
	}

	bool is_decay_product(std::pair<int, int> const & mothers){
	if(mothers.first == 0) return false;
	return mothers.second == 0 \|\| mothers.first == mothers.second;
	}

	} // namespace anonymous

	UnclusteredEvent::UnclusteredEvent(LHEF::HEPEUP const & hepeup):
	central(EventParameters{
	hepeup.scales.mur, hepeup.scales.muf, hepeup.weight()
	})
	{
	size_t in_idx = 0;
	for (int i = 0; i < hepeup.NUP; ++i) {
	// skip decay products
	// we will add them later on, but we have to ensure that
	// the decayed particle is added before
	if(is_decay_product(hepeup.MOTHUP[i])) continue;

	auto particle = extract_particle(hepeup, i);
	// needed to identify mother particles for decay products
	particle.p.set_user_index(i+1);

	if(hepeup.ISTUP[i] == status_in){
	if(in_idx > incoming.size()) {
	throw std::invalid_argument{
	"Event has too many incoming particles"
	};
	}
	incoming[in_idx++] = std::move(particle);
	}
	else outgoing.emplace_back(std::move(particle));
	}

	// add decay products
	for (int i = 0; i < hepeup.NUP; ++i) {
	if(!is_decay_product(hepeup.MOTHUP[i])) continue;
	const int mother_id = hepeup.MOTHUP[i].first;
	const auto mother = std::find_if(
	begin(outgoing), end(outgoing),
	[mother_id](Particle const & particle){
	return particle.p.user_index() == mother_id;
	}
	);
	if(mother == end(outgoing)){
	throw std::invalid_argument{"invalid decay product parent"};
	}
	const int mother_idx = std::distance(begin(outgoing), mother);
	assert(mother_idx >= 0);
	decays[mother_idx].emplace_back(extract_particle(hepeup, i));
	}
	}

	Event::Event(
	UnclusteredEvent ev,
	fastjet::JetDefinition const & jet_def, double min_jet_pt
	):
	ev_{std::move(ev)},
	cs_{to_PseudoJet(filter_partons(ev_.outgoing)), jet_def},
	min_jet_pt_{min_jet_pt}
	{
	// sort particles
	std::sort(
	begin(ev_.incoming), end(ev_.incoming),
	[](Particle o1, Particle o2){return o1.p.pz()<o2.p.pz();}
	);

	auto old_outgoing = std::move(ev_.outgoing);
	std::vector<size_t> idx(old_outgoing.size());
	std::iota(idx.begin(), idx.end(), 0);
	std::sort(idx.begin(), idx.end(), [&old_outgoing](size_t i, size_t j){
	return old_outgoing[i].rapidity() < old_outgoing[j].rapidity();
	});
	ev_.outgoing.clear();
	ev_.outgoing.reserve(old_outgoing.size());
	for(size_t i: idx) {
	ev_.outgoing.emplace_back(std::move(old_outgoing[i]));
	}

	// find decays again
	if(!ev_.decays.empty()){
	auto old_decays = std::move(ev_.decays);
	ev_.decays.clear();
	for(size_t i=0; i<idx.size(); ++i) {
	auto decay = old_decays.find(idx[i]);
	if(decay != old_decays.end())
	ev_.decays.emplace(i, std::move(decay->second));
	}
	assert(old_decays.size() == ev_.decays.size());
	}

	// classify event
	type_ = classify(*this);

	assert(std::is_sorted(begin(outgoing()), end(outgoing()), rapidity_less{}));
	}

	std::vector<fastjet::PseudoJet> Event::jets() const{
	return cs_.inclusive_jets(min_jet_pt_);
	}

	double shat(Event const & ev){
	return (ev.incoming()[0].p + ev.incoming()[1].p).m2();
	}

	namespace{
	// colour flow according to Les Houches standard
	// TODO: stub
	std::vector<std::pair<int, int>> colour_flow(
	std::array<Particle, 2> const & incoming,
	std::vector<Particle> const & outgoing
	){
	std::vector<std::pair<int, int>> result(
	incoming.size() + outgoing.size()
	);
	for(auto & col: result){
	col = std::make_pair(-1, -1);
	}
	return result;
	}
	}

	LHEF::HEPEUP to_HEPEUP(Event const & event, LHEF::HEPRUP * heprup){
	LHEF::HEPEUP result;
	result.heprup = heprup;
	result.weights = {{event.central().weight, nullptr}};
	for(auto const & var: event.variations()){
	result.weights.emplace_back(var.weight, nullptr);
	}
	size_t num_particles = event.incoming().size() + event.outgoing().size();
	for(auto const & decay: event.decays()) num_particles += decay.second.size();
	result.NUP = num_particles;
	// the following entries are pretty much meaningless
	result.IDPRUP = event.type()+1; // event ID
	result.AQEDUP = 1./128.; // alpha_EW
	//result.AQCDUP = 0.118 // alpha_QCD
	// end meaningless part
	result.XWGTUP = event.central().weight;
	result.SCALUP = event.central().muf;
	result.scales.muf = event.central().muf;
	result.scales.mur = event.central().mur;
	result.scales.SCALUP = event.central().muf;
	result.pdfinfo.p1 = event.incoming().front().type;
	result.pdfinfo.p2 = event.incoming().back().type;
	result.pdfinfo.scale = event.central().muf;
	for(Particle const & in: event.incoming()){
	result.IDUP.emplace_back(in.type);
	result.ISTUP.emplace_back(status_in);
	result.PUP.push_back({in.p[0], in.p[1], in.p[2], in.p[3], in.p.m()});
	result.MOTHUP.emplace_back(0, 0);
	}
	for(size_t i = 0; i < event.outgoing().size(); ++i){
	Particle const & out = event.outgoing()[i];
	result.IDUP.emplace_back(out.type);
	const int status = event.decays().count(i)?status_decayed:status_out;
	result.ISTUP.emplace_back(status);
	result.PUP.push_back({out.p[0], out.p[1], out.p[2], out.p[3], out.p.m()});
	result.MOTHUP.emplace_back(1, 2);
	}
	result.ICOLUP = colour_flow(
	event.incoming(), filter_partons(event.outgoing())
	);
	if(result.ICOLUP.size() < num_particles){
	const size_t AWZH_boson_idx = std::find_if(
	begin(event.outgoing()), end(event.outgoing()),
	[](Particle const & s){ return is_AWZH_boson(s); }
	) - begin(event.outgoing()) + event.incoming().size();
	assert(AWZH_boson_idx <= result.ICOLUP.size());
	result.ICOLUP.insert(
	begin(result.ICOLUP) + AWZH_boson_idx,
	std::make_pair(0,0)
	);
	}
	for(auto const & decay: event.decays()){
	for(auto const out: decay.second){
	result.IDUP.emplace_back(out.type);
	result.ISTUP.emplace_back(status_out);
	result.PUP.push_back({out.p[0], out.p[1], out.p[2], out.p[3], out.p.m()});
	const size_t mother_idx = 1 + event.incoming().size() + decay.first;
	result.MOTHUP.emplace_back(mother_idx, mother_idx);
	result.ICOLUP.emplace_back(0,0);
	}
	}
	assert(result.ICOLUP.size() == num_particles);
	static constexpr double unknown_spin = 9.; //per Les Houches accord
	result.VTIMUP = std::vector<double>(num_particles, unknown_spin);
	result.SPINUP = result.VTIMUP;
	return result;
	}

	}
	diff --git a/src/EventReweighter.cc b/src/EventReweighter.cc
	index fce0ab2..b4f613a 100644
	--- a/src/EventReweighter.cc
	+++ b/src/EventReweighter.cc
	@@ -1,259 +1,260 @@
	#include "HEJ/EventReweighter.hh"

	#include <string>
	#include <unordered_map>

	#include "HEJ/exceptions.hh"
	#include "HEJ/PhaseSpacePoint.hh"
	#include "HEJ/PDG_codes.hh"
	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	+#include "HEJ/Particle.hh"

	namespace HEJ{
	using EventType = event_type::EventType;

	namespace {

	static_assert(
	std::numeric_limits<double>::has_quiet_NaN,
	"no quiet NaN for double"
	);
	constexpr double NaN = std::numeric_limits<double>::quiet_NaN();

	UnclusteredEvent to_UnclusteredEvent(PhaseSpacePoint const & psp){
	UnclusteredEvent result;
	result.incoming = psp.incoming();
	std::sort(
	begin(result.incoming), end(result.incoming),
	[](Particle o1, Particle o2){return o1.p.pz()<o2.p.pz();}
	);
	assert(result.incoming.size() == 2);
	result.outgoing = psp.outgoing();
	assert(
	std::is_sorted(
	begin(result.outgoing), end(result.outgoing),
	rapidity_less{}
	)
	);
	assert(result.outgoing.size() >= 2);
	result.decays = psp.decays();
	result.central.mur = NaN;
	result.central.muf = NaN;
	result.central.weight = psp.weight();
	return result;
	}

	} // namespace anonymous

	EventReweighter::EventReweighter(
	LHEF::HEPRUP const & heprup,
	ScaleGenerator scale_gen,
	EventReweighterConfig conf,
	HEJ::RNG & ran
	):
	EventReweighter{
	HEJ::Beam{
	heprup.EBMUP.first,
	{{
	static_cast<HEJ::ParticleID>(heprup.IDBMUP.first),
	static_cast<HEJ::ParticleID>(heprup.IDBMUP.second)
	}}
	},
	heprup.PDFSUP.first,
	std::move(scale_gen),
	std::move(conf),
	ran
	}
	{
	if(heprup.EBMUP.second != E_beam_){
	throw std::invalid_argument(
	"asymmetric beam: " + std::to_string(E_beam_)
	+ " ---> <--- " + std::to_string(heprup.EBMUP.second)
	);
	};
	if(heprup.PDFSUP.second != pdf_.id()){
	throw std::invalid_argument(
	"conflicting PDF ids: " + std::to_string(pdf_.id())
	+ " vs. " + std::to_string(heprup.PDFSUP.second)
	);
	}
	}

	EventReweighter::EventReweighter(
	Beam beam,
	int pdf_id,
	ScaleGenerator scale_gen,
	EventReweighterConfig conf,
	HEJ::RNG & ran
	):
	param_{std::move(conf)},
	E_beam_{beam.E},
	pdf_{pdf_id, beam.type.front(), beam.type.back()},
	MEt2_{
	[this](double mu){ return pdf_.Halphas(mu); },
	param_.ME_config
	},
	scale_gen_(std::move(scale_gen)),
	ran_{ran}
	{}

	PDF const & EventReweighter::pdf() const{
	return pdf_;
	}

	std::vector<Event> EventReweighter::reweight(
	Event const & input_ev, int num_events
	){
	auto res_events = gen_res_events(input_ev, num_events);
	if(res_events.empty()) return {};
	for(auto & event: res_events) event = scale_gen_(event);
	return rescale(input_ev, std::move(res_events));
	}

	std::vector<Event> EventReweighter::gen_res_events(
	Event const & ev,
	int phase_space_points
	){
	assert(ev.variations().empty());

	switch(param_.treat.at(ev.type())){
	case EventTreatment::discard: return {};
	case EventTreatment::keep:
	if(! jets_pass_resummation_cuts(ev)) return {};
	else return {ev};
	default:;
	}
	const double Born_shat = shat(ev);

	std::vector<Event> resummation_events;
	for(int psp_number = 0; psp_number < phase_space_points; ++psp_number){
	PhaseSpacePoint psp{ev, param_.psp_config, ran_};
	if(psp.weight() == 0.) continue;
	if(psp.incoming()[0].E() > E_beam_ \|\| psp.incoming()[1].E() > E_beam_) continue;

	resummation_events.emplace_back(
	to_UnclusteredEvent(std::move(psp)),
	param_.jet_param.def, param_.jet_param.min_pt
	);
	auto & new_event = resummation_events.back();
	assert(new_event.variations().empty());
	new_event.central().mur = ev.central().mur;
	new_event.central().muf = ev.central().muf;
	const double resum_shat = shat(new_event);
	new_event.central().weight = ev.central().weightBorn_shat*Born_shat/
	(phase_space_pointsresum_shatresum_shat);
	}
	return resummation_events;
	}

	std::vector<Event> EventReweighter::rescale(
	Event const & Born_ev,
	std::vector<Event> events
	) const{
	const double Born_pdf = pdf_factors(Born_ev).central;
	const double Born_ME = tree_matrix_element(Born_ev);

	for(auto & cur_event: events){
	const auto pdf = pdf_factors(cur_event);
	assert(pdf.variations.size() == cur_event.variations().size());
	const auto ME = matrix_elements(cur_event);
	assert(ME.variations.size() == cur_event.variations().size());
	cur_event.central().weight = pdf.centralME.central/(Born_pdf*Born_ME);
	for(size_t i = 0; i < cur_event.variations().size(); ++i){
	cur_event.variations(i).weight *=
	pdf.variations[i]ME.variations[i]/(Born_pdfBorn_ME);
	}
	}
	return events;
	};

	bool EventReweighter::jets_pass_resummation_cuts(
	Event const & ev
	) const{
	const auto out_as_PseudoJet = to_PseudoJet(filter_partons(ev.outgoing()));
	fastjet::ClusterSequence cs{out_as_PseudoJet, param_.jet_param.def};
	return cs.inclusive_jets(param_.jet_param.min_pt).size() == ev.jets().size();
	}

	Weights
	EventReweighter::pdf_factors(Event const & ev) const{
	auto const & a = ev.incoming().front();
	auto const & b = ev.incoming().back();
	const double xa = a.p.e()/E_beam_;
	const double xb = b.p.e()/E_beam_;

	Weights result;
	std::unordered_map<double, double> known_pdf;
	result.central =
	pdf_.pdfpt(0,xa,ev.central().muf,a.type)*
	pdf_.pdfpt(1,xb,ev.central().muf,b.type);
	known_pdf.emplace(ev.central().muf, result.central);

	result.variations.reserve(ev.variations().size());
	for(auto const & ev_param: ev.variations()){
	const double muf = ev_param.muf;
	auto cur_pdf = known_pdf.find(muf);
	if(cur_pdf == known_pdf.end()){
	cur_pdf = known_pdf.emplace(
	muf,
	pdf_.pdfpt(0,xa,muf,a.type)*pdf_.pdfpt(1,xb,muf,b.type)
	).first;
	}
	result.variations.emplace_back(cur_pdf->second);
	}
	assert(result.variations.size() == ev.variations().size());
	return result;
	}

	Weights
	EventReweighter::matrix_elements(Event const & ev) const{
	assert(param_.treat.count(ev.type()) > 0);
	if(param_.treat.find(ev.type())->second == EventTreatment::keep){
	return fixed_order_scale_ME(ev);
	}

	return MEt2_(ev);
	}

	double EventReweighter::tree_matrix_element(Event const & ev) const{
	assert(ev.variations().empty());
	assert(param_.treat.count(ev.type()) > 0);
	if(param_.treat.find(ev.type())->second == EventTreatment::keep){
	return fixed_order_scale_ME(ev).central;
	}
	return MEt2_.tree(ev).central;
	}

	Weights
	EventReweighter::fixed_order_scale_ME(Event const & ev) const{
	int alpha_s_power = 0;
	for(auto const & part: ev.outgoing()){
	if(is_parton(part))
	++alpha_s_power;
	else {
	switch(part.type){
	case pid::Higgs: {
	alpha_s_power += 2;
	break;
	}
	// TODO
	case pid::Wp:
	case pid::Wm:
	case pid::photon:
	case pid::Z:
	default:
	throw not_implemented("Emission of boson of unsupported type");
	}
	}
	}

	Weights result;
	result.central = pow(pdf_.Halphas(ev.central().mur), alpha_s_power);
	for(auto const & var: ev.variations()){
	result.variations.emplace_back(
	pow(pdf_.Halphas(var.mur), alpha_s_power)
	);
	}
	return result;
	}

	} // namespace HEJ
	diff --git a/src/HepMCInterface.cc b/src/HepMCInterface.cc
	index 86a6a41..abd36a3 100644
	--- a/src/HepMCInterface.cc
	+++ b/src/HepMCInterface.cc
	@@ -1,170 +1,171 @@
	#include "HEJ/HepMCInterface.hh"

	#include <cassert>

	#ifdef HEJ_BUILD_WITH_HepMC_VERSION

	#include "HEJ/Event.hh"
	+#include "HEJ/Particle.hh"

	#include "HepMC/GenEvent.h"
	#include "HepMC/GenVertex.h"
	#include "HepMC/GenParticle.h"
	#include "HepMC/GenCrossSection.h"

	#include "LHEF/LHEF.h"

	namespace HEJ{

	namespace {
	HepMC::FourVector to_FourVector(Particle const & sp){
	return {sp.px(), sp.py(), sp.pz(), sp.E()};
	}
	constexpr int status_in = -1;
	constexpr int status_decayed = 3;
	constexpr int status_out = 1;

	template<class HepMCClass, typename... Args>
	auto make_ptr(Args&&... args){
	#if HEJ_BUILD_WITH_HepMC_VERSION >= 3
	return HepMC::make_shared<HepMCClass>(std::forward<Args>(args)...);
	#else
	return new HepMCClass(std::forward<Args>(args)...);
	#endif
	}
	} // namespace anonymous

	HepMCInterface::HepMCInterface():
	event_count_(0.), tot_weight_(0.), tot_weight2_(0.)
	{}

	HepMC::GenCrossSection HepMCInterface::cross_section() const {
	HepMC::GenCrossSection xs;
	#if HEJ_BUILD_WITH_HepMC_VERSION >= 3
	xs.set_cross_section(tot_weight_, sqrt(tot_weight2_), event_count_);
	/// @TODO add number of attempted events
	#else // HepMC 2
	xs.set_cross_section(tot_weight_, sqrt(tot_weight2_));
	#endif
	return xs;
	}

	HepMC::GenEvent HepMCInterface::init_kinematics(Event const & event) {
	HepMC::GenEvent out_ev{HepMC::Units::GEV, HepMC::Units::MM};
	auto vx = make_ptr<HepMC::GenVertex>();
	for(auto const & in: event.incoming()){
	vx->add_particle_in(
	make_ptr<HepMC::GenParticle>(
	to_FourVector(in), static_cast<int>(in.type), status_in
	)
	);
	}
	for(size_t i=0; i < event.outgoing().size(); ++i){
	auto const & out = event.outgoing()[i];
	auto particle = make_ptr<HepMC::GenParticle>(
	to_FourVector(out), static_cast<int>(out.type), status_out
	);
	const int status = event.decays().count(i)?status_decayed:status_out;
	particle->set_status(status);
	if( status == status_decayed){
	auto vx_decay = make_ptr<HepMC::GenVertex>();
	vx_decay->add_particle_in(particle);
	for( auto const & out: event.decays().at(i)){
	vx_decay->add_particle_out(
	make_ptr<HepMC::GenParticle>(
	to_FourVector(out), static_cast<int>(out.type), status_out
	)
	);
	}
	out_ev.add_vertex(vx_decay);
	}
	vx->add_particle_out(particle);
	}
	out_ev.add_vertex(vx);

	return out_ev;
	}

	void HepMCInterface::set_central(HepMC::GenEvent & out_ev, Event const & event,
	ssize_t const weight_index
	) {
	EventParameters event_param;
	if(weight_index < 0)
	event_param = event.central();
	else if ( (size_t) weight_index < event.variations().size())
	event_param = event.variations(weight_index);
	else
	throw std::invalid_argument{
	"HepMCInterface tried to access a weight outside of the variation range."
	};
	const double wt = event_param.weight;

	tot_weight_ += wt;
	tot_weight2_ += wt * wt;

	if(out_ev.weights().size() == 0){
	out_ev.weights().push_back(wt);
	} else { // central always on first
	out_ev.weights()[0] = wt;
	}

	#if HEJ_BUILD_WITH_HepMC_VERSION >= 3
	out_ev.set_cross_section(
	HepMC::make_shared<HepMC::GenCrossSection>(cross_section()) );
	#else // HepMC 2
	out_ev.set_cross_section( cross_section() );
	out_ev.set_signal_process_id(event.type()+1); // "+1": conistent with lhe
	out_ev.set_event_scale(event_param.mur);
	#endif

	++event_count_;
	out_ev.set_event_number(event_count_);

	/// @TODO add alphaQCD (need function) and alphaQED
	/// @TODO output pdf (currently not avaiable from event alone)

	}

	void HepMCInterface::add_variation(HepMC::GenEvent & out_ev,
	std::vector<EventParameters> const & varis
	) {
	for(auto const & var: varis){
	out_ev.weights().push_back(var.weight);
	}
	/// @TODO add name list for weights
	}

	HepMC::GenEvent HepMCInterface::operator()(Event const & event,
	ssize_t const weight_index
	) {
	HepMC::GenEvent out_ev(init_kinematics(event));
	set_central(out_ev, event, weight_index);
	add_variation(out_ev, event.variations());
	return out_ev;
	}


	}
	#else // no HepMC => empty class
	namespace HepMC {
	class GenEvent {};
	class GenCrossSection {};
	}
	namespace HEJ{
	HepMCInterface::HepMCInterface(){
	throw std::invalid_argument(
	"Failed to create HepMCInterface: "
	"HEJ 2 was built without HepMC support"
	);
	}

	HepMC::GenEvent HepMCInterface::operator()(Event const &, ssize_t)
	{return HepMC::GenEvent();}
	HepMC::GenEvent HepMCInterface::init_kinematics(Event const &)
	{return HepMC::GenEvent();}
	void HepMCInterface::add_variation(HepMC::GenEvent &,
	std::vector<EventParameters> const &){}
	void HepMCInterface::set_central(HepMC::GenEvent &, Event const &, ssize_t) {}
	HepMC::GenCrossSection HepMCInterface::cross_section() const
	{return HepMC::GenCrossSection();}
	}
	#endif
	diff --git a/src/HepMCWriter.cc b/src/HepMCWriter.cc
	index de08051..fee0ac5 100644
	--- a/src/HepMCWriter.cc
	+++ b/src/HepMCWriter.cc
	@@ -1,139 +1,139 @@
	#include "HEJ/HepMCWriter.hh"

	#include <cassert>

	#ifdef HEJ_BUILD_WITH_HepMC_VERSION

	#if HEJ_BUILD_WITH_HepMC_VERSION >= 3
	#include "HepMC/WriterAscii.h"
	#include "HepMC/LHEFAttributes.h"

	#include "HEJ/Version.hh"
	#else
	#include "HepMC/IO_GenEvent.h"
	#endif

	#include "HepMC/GenVertex.h"
	#include "HepMC/GenParticle.h"

	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/Event.hh"
	#include "HEJ/exceptions.hh"
	#include "HEJ/HepMCInterface.hh"

	#if HEJ_BUILD_WITH_HepMC_VERSION >= 3
	namespace {
	void reset_weight_info(LHEF::HEPRUP & heprup){
	heprup.IDWTUP = 2;
	// use placeholders for unknown init block values
	// we can overwrite them after processing all events
	heprup.XSECUP = {0.};
	heprup.XERRUP = {0.};
	heprup.XMAXUP = {0.};
	}
	HepMC::shared_ptr<HepMC::GenRunInfo> init_runinfo(LHEF::HEPRUP && heprup){
	reset_weight_info(heprup);
	HepMC::GenRunInfo runinfo;

	auto hepr = HepMC::make_shared<HepMC::HEPRUPAttribute>();
	hepr->heprup = heprup;
	runinfo.add_attribute(std::string("HEPRUP"), hepr);

	for (int i = 0, N = hepr->heprup.generators.size(); i < N; ++i ){
	HepMC::GenRunInfo::ToolInfo tool;
	tool.name = hepr->heprup.generators[i].name;
	tool.version = hepr->heprup.generators[i].version;
	tool.description = hepr->heprup.generators[i].contents;
	runinfo.tools().push_back(tool);
	}
	return HepMC::make_shared<HepMC::GenRunInfo>(runinfo);
	}

	} // namespace anonymous
	#endif // HepMC 3

	namespace HEJ{

	struct HepMCWriter::HepMCWriterImpl{
	HepMCInterface hepmc_;

	HepMCWriterImpl & operator=(HepMCWriterImpl const & other) = delete;
	HepMCWriterImpl(HepMCWriterImpl const & other) = delete;
	HepMCWriterImpl & operator=(HepMCWriterImpl && other) = delete;
	HepMCWriterImpl(HepMCWriterImpl && other) = delete;

	#if HEJ_BUILD_WITH_HepMC_VERSION >= 3

	HepMC::WriterAscii writer_;

	HepMCWriterImpl(
	std::string const & file, LHEF::HEPRUP && heprup
	):
	hepmc_(),
	writer_{file, init_runinfo(std::move(heprup))}
	{}

	~HepMCWriterImpl(){
	writer_.close();
	}

	#else // HepMC 2

	HepMC::IO_GenEvent writer_;

	HepMCWriterImpl(
	std::string const & file, LHEF::HEPRUP &&
	):
	hepmc_(),
	writer_{file}
	{}

	#endif

	void write(Event const & ev){
	auto out_ev = hepmc_(ev);
	#if HEJ_BUILD_WITH_HepMC_VERSION >= 3
	writer_.write_event(out_ev);
	#else // HepMC 2
	writer_.write_event(&out_ev);
	#endif
	}
	};

	void HepMCWriter::HepMCWriterImplDeleter::operator()(HepMCWriterImpl* p) {
	delete p;
	}

	HepMCWriter::HepMCWriter(std::string const & file, LHEF::HEPRUP heprup):
	impl_{std::unique_ptr<HepMCWriterImpl, HepMCWriterImplDeleter>{
	new HepMCWriterImpl(file, std::move(heprup))
	}}
	{}

	void HepMCWriter::write(Event const & ev){
	impl_->write(ev);
	}
	} // namespace HEJ

	#else // no HepMC

	namespace HEJ{

	class HepMCWriter::HepMCWriterImpl{};

	HepMCWriter::HepMCWriter(std::string const &, LHEF::HEPRUP){
	throw std::invalid_argument(
	"Failed to create HepMC writer: "
	"HEJ 2 was built without HepMC support"
	);
	}

	void HepMCWriter::write(Event const &){
	assert(false);
	}

	void HepMCWriter::HepMCWriterImplDeleter::operator()(HepMCWriterImpl* p) {
	delete p;
	}
	}
	#endif
	diff --git a/src/MatrixElement.cc b/src/MatrixElement.cc
	index f52fc91..2f26540 100644
	--- a/src/MatrixElement.cc
	+++ b/src/MatrixElement.cc
	@@ -1,839 +1,840 @@
	#include "HEJ/MatrixElement.hh"

	#include <unordered_map>

	#include <CLHEP/Random/Randomize.h>
	#include <CLHEP/Random/RanluxEngine.h>

	#include "HEJ/Constants.hh"
	#include "HEJ/currents.hh"
	#include "HEJ/exceptions.hh"
	#include "HEJ/PDG_codes.hh"
	#include "HEJ/event_types.hh"
	#include "HEJ/utility.hh"
	+#include "HEJ/Particle.hh"

	namespace HEJ{
	//cf. last line of eq. (22) in \ref Andersen:2011hs
	double MatrixElement::omega0(
	double alpha_s, double mur,
	fastjet::PseudoJet const & q_j, double lambda
	) const {
	const double result = - alpha_sN_C/M_PIlog(q_j.perp2()/(lambda*lambda));
	if(! param_.log_correction) return result;
	// use alpha_s(sqrt(q_j*lambda)), evolved to mur
	return (
	1. + alpha_s/(4.M_PI)beta0log(murmur/(q_j.perp()*lambda))
	)*result;
	}

	Weights MatrixElement::operator()(
	Event const & event
	) const {
	return tree(event)*virtual_corrections(event);
	}

	Weights MatrixElement::tree(
	Event const & event
	) const {
	if(! is_HEJ(event.type())) {
	return Weights{0., std::vector<double>(event.variations().size(), 0.)};
	}
	return tree_param(event)*tree_kin(event);
	}

	Weights MatrixElement::tree_param(
	Event const & event
	) const {
	Weights result;
	// only compute once for each renormalisation scale
	std::unordered_map<double, double> known;
	result.central = tree_param(event, event.central().mur);
	known.emplace(event.central().mur, result.central);
	for(auto const & var: event.variations()) {
	const auto ME_it = known.find(var.mur);
	if(ME_it == end(known)) {
	const double wt = tree_param(event, var.mur);
	result.variations.emplace_back(wt);
	known.emplace(var.mur, wt);
	}
	else {
	result.variations.emplace_back(ME_it->second);
	}
	}
	return result;
	}

	Weights MatrixElement::virtual_corrections(
	Event const & event
	) const {
	if(! is_HEJ(event.type())) {
	return Weights{0., std::vector<double>(event.variations().size(), 0.)};
	}
	Weights result;
	// only compute once for each renormalisation scale
	std::unordered_map<double, double> known;
	result.central = virtual_corrections(event, event.central().mur);
	known.emplace(event.central().mur, result.central);
	for(auto const & var: event.variations()) {
	const auto ME_it = known.find(var.mur);
	if(ME_it == end(known)) {
	const double wt = virtual_corrections(event, var.mur);
	result.variations.emplace_back(wt);
	known.emplace(var.mur, wt);
	}
	else {
	result.variations.emplace_back(ME_it->second);
	}
	}
	return result;
	}

	double MatrixElement::virtual_corrections(
	Event const & event,
	double mur
	) const{
	auto const & in = event.incoming();
	auto const & out = event.outgoing();
	fastjet::PseudoJet const & pa = in.front().p;
	#ifndef NDEBUG
	fastjet::PseudoJet const & pb = in.back().p;
	double const norm = (in.front().p + in.back().p).E();
	#endif

	assert(std::is_sorted(out.begin(), out.end(), rapidity_less{}));
	assert(out.size() >= 2);
	assert(pa.pz() < pb.pz());

	fastjet::PseudoJet q = pa - out[0].p;
	size_t first_idx = 0;
	size_t last_idx = out.size() - 1;
	// if there is a Higgs or unordered gluon outside the extremal partons
	// then it is not part of the FKL ladder and does not contribute
	// to the virtual corrections
	if(out.front().type == pid::Higgs \|\| event.type() == event_type::unob){
	q -= out[1].p;
	++first_idx;
	}
	if(out.back().type == pid::Higgs \|\| event.type() == event_type::unof){
	--last_idx;
	}

	double exponent = 0;
	const double alpha_s = alpha_s_(mur);
	for(size_t j = first_idx; j < last_idx; ++j){
	exponent += omega0(alpha_s, mur, q, CLAMBDA)*(
	out[j+1].rapidity() - out[j].rapidity()
	);
	q -= out[j+1].p;
	}
	assert(
	nearby(q, -1*pb, norm)
	\|\| out.back().type == pid::Higgs
	\|\| event.type() == event_type::unof
	);
	return exp(exponent);
	}
	} // namespace HEJ

	namespace {
	//! Lipatov vertex for partons emitted into extremal jets
	double C2Lipatov(CLHEP::HepLorentzVector qav, CLHEP::HepLorentzVector qbv,
	CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector p2)
	{
	CLHEP::HepLorentzVector temptrans=-(qav+qbv);
	CLHEP::HepLorentzVector p5=qav-qbv;
	CLHEP::HepLorentzVector CL=temptrans
	+ p1(qav.m2()/p5.dot(p1) + 2.p5.dot(p2)/p1.dot(p2))
	- p2(qbv.m2()/p5.dot(p2) + 2.p5.dot(p1)/p1.dot(p2));
	return -CL.dot(CL);
	}

	//! Lipatov vertex with soft subtraction for partons emitted into extremal jets
	double C2Lipatovots(CLHEP::HepLorentzVector qav, CLHEP::HepLorentzVector qbv,
	CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector p2)
	{
	double kperp=(qav-qbv).perp();
	if (kperp>HEJ::CLAMBDA)
	return C2Lipatov(qav, qbv, p1, p2)/(qav.m2()*qbv.m2());
	else {
	double Cls=(C2Lipatov(qav, qbv, p1, p2)/(qav.m2()*qbv.m2()));
	return Cls-4./(kperp*kperp);
	}
	}

	//! Lipatov vertex
	double C2Lipatov(CLHEP::HepLorentzVector qav, CLHEP::HepLorentzVector qbv,
	CLHEP::HepLorentzVector pim, CLHEP::HepLorentzVector pip,
	CLHEP::HepLorentzVector pom, CLHEP::HepLorentzVector pop) // B
	{
	CLHEP::HepLorentzVector temptrans=-(qav+qbv);
	CLHEP::HepLorentzVector p5=qav-qbv;
	CLHEP::HepLorentzVector CL=temptrans
	+ qav.m2()(1./p5.dot(pip)pip + 1./p5.dot(pop)*pop)/2.
	- qbv.m2()(1./p5.dot(pim)pim + 1./p5.dot(pom)*pom)/2.
	+ ( pip*(p5.dot(pim)/pip.dot(pim) + p5.dot(pom)/pip.dot(pom))
	+ pop*(p5.dot(pim)/pop.dot(pim) + p5.dot(pom)/pop.dot(pom))
	- pim*(p5.dot(pip)/pip.dot(pim) + p5.dot(pop)/pop.dot(pim))
	- pom*(p5.dot(pip)/pip.dot(pom) + p5.dot(pop)/pop.dot(pom)) )/2.;

	return -CL.dot(CL);
	}

	//! Lipatov vertex with soft subtraction
	double C2Lipatovots(CLHEP::HepLorentzVector qav, CLHEP::HepLorentzVector qbv,
	CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector pb,
	CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector p2)
	{
	double kperp=(qav-qbv).perp();
	if (kperp>HEJ::CLAMBDA)
	return C2Lipatov(qav, qbv, pa, pb, p1, p2)/(qav.m2()*qbv.m2());
	else {
	double Cls=(C2Lipatov(qav, qbv, pa, pb, p1, p2)/(qav.m2()*qbv.m2()));
	double temp=Cls-4./(kperp*kperp);
	return temp;
	}
	}

	/** Matrix element squared for tree-level current-current scattering
	* @param aptype Particle a PDG ID
	* @param bptype Particle b PDG ID
	* @param pn Particle n Momentum
	* @param pb Particle b Momentum
	* @param p1 Particle 1 Momentum
	* @param pa Particle a Momentum
	* @returns ME Squared for Tree-Level Current-Current Scattering
	*/
	double ME_current(
	int aptype, int bptype,
	CLHEP::HepLorentzVector const & pn,
	CLHEP::HepLorentzVector const & pb,
	CLHEP::HepLorentzVector const & p1,
	CLHEP::HepLorentzVector const & pa
	){
	if (aptype==21&&bptype==21) {
	return jM2gg(pn,pb,p1,pa);
	} else if (aptype==21&&bptype!=21) {
	if (bptype > 0)
	return jM2qg(pn,pb,p1,pa);
	else
	return jM2qbarg(pn,pb,p1,pa);
	}
	else if (bptype==21&&aptype!=21) { // ----- \|\| -----
	if (aptype > 0)
	return jM2qg(p1,pa,pn,pb);
	else
	return jM2qbarg(p1,pa,pn,pb);
	}
	else { // they are both quark
	if (bptype>0) {
	if (aptype>0)
	return jM2qQ(pn,pb,p1,pa);
	else
	return jM2qQbar(pn,pb,p1,pa);
	}
	else {
	if (aptype>0)
	return jM2qQbar(p1,pa,pn,pb);
	else
	return jM2qbarQbar(pn,pb,p1,pa);
	}
	}
	throw std::logic_error("unknown particle types");
	}

	/** \brief Matrix element squared for tree-level current-current scattering with Higgs
	* @param aptype Particle a PDG ID
	* @param bptype Particle b PDG ID
	* @param pn Particle n Momentum
	* @param pb Particle b Momentum
	* @param p1 Particle 1 Momentum
	* @param pa Particle a Momentum
	* @param qH t-channel momentum before Higgs
	* @param qHp1 t-channel momentum after Higgs
	* @returns ME Squared for Tree-Level Current-Current Scattering with Higgs
	*/
	double ME_Higgs_current(
	int aptype, int bptype,
	CLHEP::HepLorentzVector const & pn,
	CLHEP::HepLorentzVector const & pb,
	CLHEP::HepLorentzVector const & p1,
	CLHEP::HepLorentzVector const & pa,
	CLHEP::HepLorentzVector const & qH, // t-channel momentum before Higgs
	CLHEP::HepLorentzVector const & qHp1, // t-channel momentum after Higgs
	double mt, bool include_bottom, double mb
	){
	if (aptype==21&&bptype==21) // gg initial state
	return MH2gg(pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	else if (aptype==21&&bptype!=21) {
	if (bptype > 0)
	return MH2qg(pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb)*4./9.;
	else
	return MH2qbarg(pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb)*4./9.;
	}
	else if (bptype==21&&aptype!=21) {
	if (aptype > 0)
	return MH2qg(p1,pa,pn,pb,-qH,-qHp1,mt,include_bottom,mb)*4./9.;
	else
	return MH2qbarg(p1,pa,pn,pb,-qH,-qHp1,mt,include_bottom,mb)*4./9.;
	}
	else { // they are both quark
	if (bptype>0) {
	if (aptype>0)
	return MH2qQ(pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb)4.4./(9.*9.);
	else
	return MH2qQbar(pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb)4.4./(9.*9.);
	}
	else {
	if (aptype>0)
	return MH2qQbar(p1,pa,pn,pb,-qH,-qHp1,mt,include_bottom,mb)4.4./(9.*9.);
	else
	return MH2qbarQbar(pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb)4.4./(9.*9.);
	}
	}
	throw std::logic_error("unknown particle types");
	}

	/** \brief Current matrix element squared with Higgs and unordered forward emission
	* @param aptype Particle A PDG ID
	* @param bptype Particle B PDG ID
	* @param punof Unordered Particle Momentum
	* @param pn Particle n Momentum
	* @param pb Particle b Momentum
	* @param p1 Particle 1 Momentum
	* @param pa Particle a Momentum
	* @param qH t-channel momentum before Higgs
	* @param qHp1 t-channel momentum after Higgs
	* @returns ME Squared with Higgs and unordered forward emission
	*/
	double ME_Higgs_current_unof(
	int aptype, int bptype,
	CLHEP::HepLorentzVector const & punof,
	CLHEP::HepLorentzVector const & pn,
	CLHEP::HepLorentzVector const & pb,
	CLHEP::HepLorentzVector const & p1,
	CLHEP::HepLorentzVector const & pa,
	CLHEP::HepLorentzVector const & qH, // t-channel momentum before Higgs
	CLHEP::HepLorentzVector const & qHp1, // t-channel momentum after Higgs
	double mt, bool include_bottom, double mb
	){
	if (aptype==21&&bptype!=21) {
	if (bptype > 0)
	return jM2unogqHg(punof,pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	else
	return jM2unogqbarHg(punof,pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	}
	else { // they are both quark
	if (bptype>0) {
	if (aptype>0)
	return jM2unogqHQ(punof,pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	else
	return jM2unogqHQbar(punof,pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	}
	else {
	if (aptype>0)
	return jM2unogqbarHQ(punof,pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	else
	return jM2unogqbarHQbar(punof,pn,pb,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	}
	}
	throw std::logic_error("unknown particle types");
	}

	/** \brief Current matrix element squared with Higgs and unordered backward emission
	* @param aptype Particle A PDG ID
	* @param bptype Particle B PDG ID
	* @param pn Particle n Momentum
	* @param pb Particle b Momentum
	* @param punob Unordered back Particle Momentum
	* @param p1 Particle 1 Momentum
	* @param pa Particle a Momentum
	* @param qH t-channel momentum before Higgs
	* @param qHp1 t-channel momentum after Higgs
	* @returns ME Squared with Higgs and unordered backward emission
	*/
	double ME_Higgs_current_unob(
	int aptype, int bptype,
	CLHEP::HepLorentzVector const & pn,
	CLHEP::HepLorentzVector const & pb,
	CLHEP::HepLorentzVector const & punob,
	CLHEP::HepLorentzVector const & p1,
	CLHEP::HepLorentzVector const & pa,
	CLHEP::HepLorentzVector const & qH, // t-channel momentum before Higgs
	CLHEP::HepLorentzVector const & qHp1, // t-channel momentum after Higgs
	double mt, bool include_bottom, double mb
	){
	if (bptype==21&&aptype!=21) {
	if (aptype > 0)
	return jM2unobgHQg(pn,pb,punob,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	else
	return jM2unobgHQbarg(pn,pb,punob,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	}
	else { // they are both quark
	if (aptype>0) {
	if (bptype>0)
	return jM2unobqHQg(pn,pb,punob,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	else
	return jM2unobqbarHQg(pn,pb,punob,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	}
	else {
	if (bptype>0)
	return jM2unobqHQbarg(pn,pb,punob,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	else
	return jM2unobqbarHQbarg(pn,pb,punob,p1,pa,-qHp1,-qH,mt,include_bottom,mb);
	}
	}
	throw std::logic_error("unknown particle types");
	}

	CLHEP::HepLorentzVector to_HepLorentzVector(HEJ::Particle const & particle){
	return {particle.p.px(), particle.p.py(), particle.p.pz(), particle.p.E()};
	}

	void validate(HEJ::MatrixElementConfig const & config) {
	#ifndef HEJ_BUILD_WITH_QCDLOOP
	if(!config.Higgs_coupling.use_impact_factors) {
	throw std::invalid_argument{
	"Invalid Higgs coupling settings.\n"
	"HEJ without QCDloop support can only use impact factors.\n"
	"Set use_impact_factors to true or recompile HEJ.\n"
	};
	}
	#endif
	if(config.Higgs_coupling.use_impact_factors
	&& config.Higgs_coupling.mt != std::numeric_limits<double>::infinity()) {
	throw std::invalid_argument{
	"Conflicting settings: "
	"impact factors may only be used in the infinite top mass limit"
	};
	}
	}
	} // namespace anonymous

	namespace HEJ{
	MatrixElement::MatrixElement(
	std::function<double (double)> alpha_s,
	MatrixElementConfig conf
	):
	alpha_s_{std::move(alpha_s)},
	param_{std::move(conf)}
	{
	validate(param_);
	}

	double MatrixElement::tree_kin(
	Event const & ev
	) const {

	auto AWZH_boson = std::find_if(
	begin(ev.outgoing()), end(ev.outgoing()),
	[](Particle const & p){return is_AWZH_boson(p);}
	);

	if(AWZH_boson == end(ev.outgoing())){
	return tree_kin_jets(ev);
	}

	switch(AWZH_boson->type){
	case pid::Higgs: {
	return tree_kin_Higgs(ev);
	}
	// TODO
	case pid::Wp:
	case pid::Wm:
	case pid::photon:
	case pid::Z:
	default:
	throw not_implemented("Emission of boson of unsupported type");
	}
	}

	namespace{
	constexpr int extremal_jet_idx = 1;
	constexpr int no_extremal_jet_idx = 0;

	bool treat_as_extremal(Particle const & parton){
	return parton.p.user_index() == extremal_jet_idx;
	}

	template<class InputIterator>
	double FKL_ladder_weight(
	InputIterator begin_gluon, InputIterator end_gluon,
	CLHEP::HepLorentzVector const & q0,
	CLHEP::HepLorentzVector const & pa, CLHEP::HepLorentzVector const & pb,
	CLHEP::HepLorentzVector const & p1, CLHEP::HepLorentzVector const & pn
	){
	double wt = 1;
	auto qi = q0;
	for(auto gluon_it = begin_gluon; gluon_it != end_gluon; ++gluon_it){
	assert(gluon_it->type == pid::gluon);
	const auto g = to_HepLorentzVector(*gluon_it);
	const auto qip1 = qi - g;

	if(treat_as_extremal(*gluon_it)){
	wt = C2Lipatovots(qip1, qi, pa, pb)C_A;
	} else{
	wt = C2Lipatovots(qip1, qi, pa, pb, p1, pn)C_A;
	}

	qi = qip1;
	}
	return wt;
	}

	} // namespace anonymous

	std::vector<Particle> MatrixElement::tag_extremal_jet_partons(
	Event const & ev
	) const{
	auto out_partons = filter_partons(ev.outgoing());
	if(out_partons.size() == ev.jets().size()){
	// no additional emissions in extremal jets, don't need to tag anything
	for(auto & parton: out_partons){
	parton.p.set_user_index(no_extremal_jet_idx);
	}
	return out_partons;
	}
	// TODO: avoid reclustering
	fastjet::ClusterSequence cs(to_PseudoJet(out_partons), ev.jet_def());
	const auto jets = sorted_by_rapidity(cs.inclusive_jets(ev.min_jet_pt()));
	assert(jets.size() >= 2);
	auto most_backward = begin(jets);
	auto most_forward = end(jets) - 1;
	// skip jets caused by unordered emission
	if(ev.type() == event_type::unob){
	assert(jets.size() >= 3);
	++most_backward;
	}
	else if(ev.type() == event_type::unof){
	assert(jets.size() >= 3);
	--most_forward;
	}
	const auto extremal_jet_indices = cs.particle_jet_indices(
	{most_backward, most_forward}
	);
	assert(extremal_jet_indices.size() == out_partons.size());
	for(size_t i = 0; i < out_partons.size(); ++i){
	assert(HEJ::is_parton(out_partons[i]));
	const int idx = (extremal_jet_indices[i]>=0)?
	extremal_jet_idx:
	no_extremal_jet_idx;
	out_partons[i].p.set_user_index(idx);
	}
	return out_partons;
	}

	double MatrixElement::tree_kin_jets(
	Event const & ev
	) const {
	auto const & incoming = ev.incoming();
	const auto partons = tag_extremal_jet_partons(ev);
	if(is_uno(ev.type())){
	throw not_implemented("unordered emission not implemented for pure jets");
	}

	const auto pa = to_HepLorentzVector(incoming[0]);
	const auto pb = to_HepLorentzVector(incoming[1]);

	const auto p1 = to_HepLorentzVector(partons.front());
	const auto pn = to_HepLorentzVector(partons.back());

	return ME_current(
	incoming[0].type, incoming[1].type,
	pn, pb, p1, pa
	)/(4(N_CN_C - 1))*FKL_ladder_weight(
	begin(partons) + 1, end(partons) - 1,
	pa - p1, pa, pb, p1, pn
	);
	}

	double MatrixElement::tree_kin_Higgs(
	Event const & ev
	) const {
	if(is_uno(ev.type())){
	return tree_kin_Higgs_between(ev);
	}
	if(ev.outgoing().front().type == pid::Higgs){
	return tree_kin_Higgs_first(ev);
	}
	if(ev.outgoing().back().type == pid::Higgs){
	return tree_kin_Higgs_last(ev);
	}
	return tree_kin_Higgs_between(ev);
	}

	namespace {
	// Colour acceleration multipliers, for gluons see eq. (7) in arXiv:0910.5113
	// TODO: code duplication with currents.cc
	double K_g(double p1minus, double paminus) {
	return 1./2.(p1minus/paminus + paminus/p1minus)(C_A - 1./C_A) + 1./C_A;
	}
	double K_g(
	CLHEP::HepLorentzVector const & pout,
	CLHEP::HepLorentzVector const & pin
	) {
	if(pin.z() > 0) return K_g(pout.plus(), pin.plus());
	return K_g(pout.minus(), pin.minus());
	}
	double K(
	ParticleID type,
	CLHEP::HepLorentzVector const & pout,
	CLHEP::HepLorentzVector const & pin
	) {
	if(type == ParticleID::gluon) return K_g(pout, pin);
	return C_F;
	}
	// Colour factor in strict MRK limit
	double K_MRK(ParticleID type) {
	return (type == ParticleID::gluon)?C_A:C_F;
	}
	}

	double MatrixElement::MH2_forwardH(
	CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in,
	ParticleID type2,
	CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in,
	CLHEP::HepLorentzVector pH,
	double t1, double t2
	) const{
	ignore(p2out, p2in);
	const double shat = p1in.invariantMass2(p2in);
	// gluon case
	#ifdef HEJ_BUILD_WITH_QCDLOOP
	if(!param_.Higgs_coupling.use_impact_factors){
	return K(type2, p2out, p2in)C_A1./(16M_PIM_PI)t1/t2MH2gq_outsideH(
	p1out, p1in, p2out, p2in, pH,
	param_.Higgs_coupling.mt, param_.Higgs_coupling.include_bottom,
	param_.Higgs_coupling.mb
	)/(4(N_CN_C - 1));
	}
	#endif
	return K_MRK(type2)/C_A9./2.shatshat(
	C2gHgp(p1in,p1out,pH) + C2gHgm(p1in,p1out,pH)
	)/(t1*t2);
	}

	double MatrixElement::tree_kin_Higgs_first(
	Event const & ev
	) const {
	auto const & incoming = ev.incoming();
	auto const & outgoing = ev.outgoing();
	assert(outgoing.front().type == pid::Higgs);
	if(outgoing[1].type != pid::gluon) {
	assert(incoming.front().type == outgoing[1].type);
	return tree_kin_Higgs_between(ev);
	}
	const auto pH = to_HepLorentzVector(outgoing.front());
	const auto partons = tag_extremal_jet_partons(
	ev
	);

	const auto pa = to_HepLorentzVector(incoming[0]);
	const auto pb = to_HepLorentzVector(incoming[1]);

	const auto p1 = to_HepLorentzVector(partons.front());
	const auto pn = to_HepLorentzVector(partons.back());

	const auto q0 = pa - p1 - pH;

	const double t1 = q0.m2();
	const double t2 = (pn - pb).m2();

	return MH2_forwardH(
	p1, pa, incoming[1].type, pn, pb, pH,
	t1, t2
	)*FKL_ladder_weight(
	begin(partons) + 1, end(partons) - 1,
	q0, pa, pb, p1, pn
	);
	}

	double MatrixElement::tree_kin_Higgs_last(
	Event const & ev
	) const {
	auto const & incoming = ev.incoming();
	auto const & outgoing = ev.outgoing();
	assert(outgoing.back().type == pid::Higgs);
	if(outgoing[outgoing.size()-2].type != pid::gluon) {
	assert(incoming.back().type == outgoing[outgoing.size()-2].type);
	return tree_kin_Higgs_between(ev);
	}
	const auto pH = to_HepLorentzVector(outgoing.back());
	const auto partons = tag_extremal_jet_partons(
	ev
	);

	const auto pa = to_HepLorentzVector(incoming[0]);
	const auto pb = to_HepLorentzVector(incoming[1]);

	auto p1 = to_HepLorentzVector(partons.front());
	const auto pn = to_HepLorentzVector(partons.back());

	auto q0 = pa - p1;

	const double t1 = q0.m2();
	const double t2 = (pn + pH - pb).m2();

	return MH2_forwardH(
	pn, pb, incoming[0].type, p1, pa, pH,
	t2, t1
	)*FKL_ladder_weight(
	begin(partons) + 1, end(partons) - 1,
	q0, pa, pb, p1, pn
	);
	}


	double MatrixElement::tree_kin_Higgs_between(
	Event const & ev
	) const {
	using namespace event_type;
	auto const & incoming = ev.incoming();
	auto const & outgoing = ev.outgoing();

	const auto the_Higgs = std::find_if(
	begin(outgoing), end(outgoing),
	[](Particle const & s){ return s.type == pid::Higgs; }
	);
	assert(the_Higgs != end(outgoing));
	const auto pH = to_HepLorentzVector(*the_Higgs);
	const auto partons = tag_extremal_jet_partons(ev);

	const auto pa = to_HepLorentzVector(incoming[0]);
	const auto pb = to_HepLorentzVector(incoming[1]);

	auto p1 = to_HepLorentzVector(
	partons[(ev.type() == unob)?1:0]
	);
	auto pn = to_HepLorentzVector(
	partons[partons.size() - ((ev.type() == unof)?2:1)]
	);

	auto first_after_Higgs = begin(partons) + (the_Higgs-begin(outgoing));
	assert(
	(first_after_Higgs == end(partons) && (
	(ev.type() == unob)
	\|\| partons.back().type != pid::gluon
	))
	\|\| first_after_Higgs->rapidity() >= the_Higgs->rapidity()
	);
	assert(
	(first_after_Higgs == begin(partons) && (
	(ev.type() == unof)
	\|\| partons.front().type != pid::gluon
	))
	\|\| (first_after_Higgs-1)->rapidity() <= the_Higgs->rapidity()
	);
	// always treat the Higgs as if it were in between the extremal FKL partons
	if(first_after_Higgs == begin(partons)) ++first_after_Higgs;
	else if(first_after_Higgs == end(partons)) --first_after_Higgs;

	// t-channel momentum before Higgs
	auto qH = pa;
	for(auto parton_it = begin(partons); parton_it != first_after_Higgs; ++parton_it){
	qH -= to_HepLorentzVector(*parton_it);
	}

	auto q0 = pa - p1;
	auto begin_ladder = begin(partons) + 1;
	auto end_ladder = end(partons) - 1;

	double current_factor;
	if(ev.type() == unob){
	current_factor = C_AC_A/2.ME_Higgs_current_unob( // 1/2 = "K_uno"
	incoming[0].type, incoming[1].type,
	pn, pb, to_HepLorentzVector(partons.front()), p1, pa, qH, qH - pH,
	param_.Higgs_coupling.mt,
	param_.Higgs_coupling.include_bottom, param_.Higgs_coupling.mb
	);
	const auto p_unob = to_HepLorentzVector(partons.front());
	q0 -= p_unob;
	p1 += p_unob;
	++begin_ladder;
	}
	else if(ev.type() == unof){
	current_factor = C_AC_A/2.ME_Higgs_current_unof( // 1/2 = "K_uno"
	incoming[0].type, incoming[1].type,
	to_HepLorentzVector(partons.back()), pn, pb, p1, pa, qH, qH - pH,
	param_.Higgs_coupling.mt,
	param_.Higgs_coupling.include_bottom, param_.Higgs_coupling.mb
	);
	pn += to_HepLorentzVector(partons.back());
	--end_ladder;
	}
	else{
	current_factor = ME_Higgs_current(
	incoming[0].type, incoming[1].type,
	pn, pb, p1, pa, qH, qH - pH,
	param_.Higgs_coupling.mt,
	param_.Higgs_coupling.include_bottom, param_.Higgs_coupling.mb
	);
	}

	const double ladder_factor = FKL_ladder_weight(
	begin_ladder, first_after_Higgs,
	q0, pa, pb, p1, pn
	)*FKL_ladder_weight(
	first_after_Higgs, end_ladder,
	qH - pH, pa, pb, p1, pn
	);
	return current_factorC_AC_A/(N_CN_C-1.)ladder_factor;
	}

	double MatrixElement::tree_param_partons(
	double alpha_s, double mur,
	std::vector<Particle> const & partons
	) const{
	const double gs2 = 4.M_PIalpha_s;
	double wt = std::pow(gs2, partons.size());
	if(param_.log_correction){
	// use alpha_s(q_perp), evolved to mur
	assert(partons.size() >= 2);
	for(size_t i = 1; i < partons.size()-1; ++i){
	wt = 1 + alpha_s/(2M_PI)beta0log(mur/partons[i].p.perp());
	}
	}
	return wt;
	}

	double MatrixElement::tree_param(
	Event const & ev,
	double mur
	) const{
	assert(is_HEJ(ev.type()));

	const auto & out = ev.outgoing();
	const double alpha_s = alpha_s_(mur);
	auto AWZH_boson = std::find_if(
	begin(out), end(out),
	[](auto const & p){return is_AWZH_boson(p);}
	);
	double AWZH_coupling = 1.;
	if(AWZH_boson != end(out)){
	switch(AWZH_boson->type){
	case pid::Higgs: {
	AWZH_coupling = alpha_s*alpha_s;
	break;
	}
	// TODO
	case pid::Wp:
	case pid::Wm:
	case pid::photon:
	case pid::Z:
	default:
	throw not_implemented("Emission of boson of unsupported type");
	}
	}
	if(ev.type() == event_type::unob){
	return AWZH_coupling4M_PIalpha_stree_param_partons(
	alpha_s, mur, filter_partons({begin(out) + 1, end(out)})
	);
	}
	if(ev.type() == event_type::unof){
	return AWZH_coupling4M_PIalpha_stree_param_partons(
	alpha_s, mur, filter_partons({begin(out), end(out) - 1})
	);
	}
	return AWZH_coupling*tree_param_partons(alpha_s, mur, filter_partons(out));
	}

	} // namespace HEJ
	diff --git a/src/PhaseSpacePoint.cc b/src/PhaseSpacePoint.cc
	index ff32eb3..89bc3ef 100644
	--- a/src/PhaseSpacePoint.cc
	+++ b/src/PhaseSpacePoint.cc
	@@ -1,537 +1,538 @@
	#include "HEJ/PhaseSpacePoint.hh"

	#include <random>

	#include <CLHEP/Random/Randomize.h>
	#include <CLHEP/Random/RanluxEngine.h>

	#include "HEJ/Constants.hh"
	#include "HEJ/resummation_jet.hh"
	#include "HEJ/utility.hh"
	#include "HEJ/kinematics.hh"
	+#include "HEJ/Particle.hh"

	namespace HEJ{
	namespace {
	constexpr int max_jet_user_idx = PhaseSpacePoint::ng_max;

	bool is_nonjet_parton(fastjet::PseudoJet const & parton){
	assert(parton.user_index() != -1);
	return parton.user_index() > max_jet_user_idx;
	}

	bool is_jet_parton(fastjet::PseudoJet const & parton){
	assert(parton.user_index() != -1);
	return parton.user_index() <= max_jet_user_idx;
	}

	// user indices for partons with extremal rapidity
	constexpr int unob_idx = -5;
	constexpr int unof_idx = -4;
	constexpr int backward_FKL_idx = -3;
	constexpr int forward_FKL_idx = -2;
	}

	namespace {
	double estimate_ng_mean(std::vector<fastjet::PseudoJet> const & Born_jets){
	const double delta_y =
	Born_jets.back().rapidity() - Born_jets.front().rapidity();
	assert(delta_y > 0);
	// Formula derived from fit in arXiv:1805.04446 (see Fig. 2)
	return 0.975052*delta_y;
	}
	}

	std::vector<fastjet::PseudoJet> PhaseSpacePoint::cluster_jets(
	std::vector<fastjet::PseudoJet> const & partons
	) const{
	fastjet::ClusterSequence cs(partons, param_.jet_param.def);
	return cs.inclusive_jets(param_.jet_param.min_pt);
	}

	bool PhaseSpacePoint::pass_resummation_cuts(
	std::vector<fastjet::PseudoJet> const & jets
	) const{
	return cluster_jets(jets).size() == jets.size();
	}

	int PhaseSpacePoint::sample_ng(std::vector<fastjet::PseudoJet> const & Born_jets){
	const double ng_mean = estimate_ng_mean(Born_jets);
	std::poisson_distribution<int> dist(ng_mean);
	const int ng = dist(ran_.get());
	assert(ng >= 0);
	assert(ng < ng_max);
	weight_ = std::tgamma(ng + 1)std::exp(ng_mean)*std::pow(ng_mean, -ng);
	return ng;
	}

	void PhaseSpacePoint::copy_AWZH_boson_from(Event const & event){
	auto const & from = event.outgoing();

	const auto AWZH_boson = std::find_if(
	begin(from), end(from),
	[](Particle const & p){ return is_AWZH_boson(p); }
	);
	if(AWZH_boson == end(from)) return;
	auto insertion_point = std::lower_bound(
	begin(outgoing_), end(outgoing_), *AWZH_boson, rapidity_less{}
	);
	outgoing_.insert(insertion_point, *AWZH_boson);

	// copy decay products
	const int idx = std::distance(begin(from), AWZH_boson);
	assert(idx >= 0);
	const auto decay_it = event.decays().find(idx);
	if(decay_it != end(event.decays())){
	const int new_idx = std::distance(begin(outgoing_), insertion_point);
	assert(new_idx >= 0);
	assert(outgoing_[new_idx].type == AWZH_boson->type);
	decays_.emplace(new_idx, decay_it->second);
	}

	assert(std::is_sorted(begin(outgoing_), end(outgoing_), rapidity_less{}));
	}

	PhaseSpacePoint::PhaseSpacePoint(
	Event const & ev, PhaseSpacePointConfig conf, HEJ::RNG & ran
	):
	unob_{ev.type() == event_type::unob},
	unof_{ev.type() == event_type::unof},
	param_{std::move(conf)},
	ran_{ran}
	{
	weight_ = 1;
	const auto Born_jets = sorted_by_rapidity(ev.jets());
	const int ng = sample_ng(Born_jets);
	weight_ /= std::tgamma(ng + 1);
	const int ng_jets = sample_ng_jets(ng, Born_jets);
	std::vector<fastjet::PseudoJet> out_partons = gen_non_jet(
	ng - ng_jets, CMINPT, param_.jet_param.min_pt
	);
	{
	const auto qperp = std::accumulate(
	begin(out_partons), end(out_partons),
	fastjet::PseudoJet{}
	);
	const auto jets = reshuffle(Born_jets, qperp);
	if(weight_ == 0.) return;
	if(! pass_resummation_cuts(jets)){
	weight_ = 0.;
	return;
	}
	std::vector<fastjet::PseudoJet> jet_partons = split(jets, ng_jets);
	if(weight_ == 0.) return;
	rescale_rapidities(
	out_partons,
	most_backward_FKL(jet_partons).rapidity(),
	most_forward_FKL(jet_partons).rapidity()
	);
	if(! cluster_jets(out_partons).empty()){
	weight_ = 0.;
	return;
	}
	std::sort(begin(out_partons), end(out_partons), rapidity_less{});
	assert(
	std::is_sorted(begin(jet_partons), end(jet_partons), rapidity_less{})
	);
	const auto first_jet_parton = out_partons.insert(
	end(out_partons), begin(jet_partons), end(jet_partons)
	);
	std::inplace_merge(
	begin(out_partons), first_jet_parton, end(out_partons), rapidity_less{}
	);
	}
	if(! jets_ok(Born_jets, out_partons)){
	weight_ = 0.;
	return;
	}
	weight_ *= phase_space_normalisation(Born_jets.size(), out_partons.size());

	outgoing_.reserve(out_partons.size() + 1); // one slot for possible A, W, Z, H
	for(auto & p: out_partons){
	outgoing_.emplace_back(Particle{pid::gluon, std::move(p)});
	}
	most_backward_FKL(outgoing_).type = ev.incoming().front().type;
	most_forward_FKL(outgoing_).type = ev.incoming().back().type;
	copy_AWZH_boson_from(ev);

	assert(!outgoing_.empty());
	reconstruct_incoming(ev.incoming());
	}

	std::vector<fastjet::PseudoJet> PhaseSpacePoint::gen_non_jet(
	int count, double ptmin, double ptmax
	){
	// heuristic parameters for pt sampling
	const double ptpar = 1.3 + count/5.;
	const double temp1 = atan((ptmax - ptmin)/ptpar);

	std::vector<fastjet::PseudoJet> partons(count);
	for(size_t i = 0; i < (size_t) count; ++i){
	const double r1 = ran_.get().flat();
	const double pt = ptmin + ptpartan(r1temp1);
	const double temp2 = cos(r1*temp1);
	const double phi = 2M_PIran_.get().flat();
	weight_ = 2.0M_PIptptpartemp1/(temp2temp2);
	// we don't know the allowed rapidity span yet,
	// set a random value to be rescaled later on
	const double y = ran_.get().flat();
	partons[i].reset_PtYPhiM(pt, y, phi);
	// Set user index higher than any jet-parton index
	// in order to assert that these are not inside jets
	partons[i].set_user_index(i + 1 + ng_max);

	assert(ptmin-1e-5 <= partons[i].pt() && partons[i].pt() <= ptmax+1e-5);
	}
	assert(std::all_of(partons.cbegin(), partons.cend(), is_nonjet_parton));
	return partons;
	}

	void PhaseSpacePoint::rescale_rapidities(
	std::vector<fastjet::PseudoJet> & partons,
	double ymin, double ymax
	){
	constexpr double ep = 1e-7;
	for(auto & parton: partons){
	assert(0 <= parton.rapidity() && parton.rapidity() <= 1);
	const double dy = ymax - ymin - 2*ep;
	const double y = ymin + ep + dy*parton.rapidity();
	parton.reset_momentum_PtYPhiM(parton.pt(), y, parton.phi());
	weight_ *= dy;
	assert(ymin <= parton.rapidity() && parton.rapidity() <= ymax);
	}
	}

	namespace {
	template<typename T, typename... Rest>
	auto min(T const & a, T const & b, Rest&&... r) {
	using std::min;
	return min(a, min(b, std::forward<Rest>(r)...));
	}
	}

	double PhaseSpacePoint::probability_in_jet(
	std::vector<fastjet::PseudoJet> const & Born_jets
	) const{
	assert(std::is_sorted(begin(Born_jets), end(Born_jets), rapidity_less{}));
	assert(Born_jets.size() >= 2);

	const double dy =
	Born_jets.back().rapidity() - Born_jets.front().rapidity();
	const double R = param_.jet_param.def.R();
	const int njets = Born_jets.size();
	const double p_J_y_large = (njets-1)RR/(2.*dy);
	const double p_J_y0 = njets*R/M_PI;
	return min(p_J_y_large, p_J_y0, 1.);
	}

	int PhaseSpacePoint::sample_ng_jets(
	int ng, std::vector<fastjet::PseudoJet> const & Born_jets
	){
	const double p_J = probability_in_jet(Born_jets);
	std::binomial_distribution<> bin_dist(ng, p_J);
	const int ng_J = bin_dist(ran_.get());
	weight_ = std::pow(p_J, -ng_J)std::pow(1 - p_J, ng_J - ng);
	return ng_J;
	}

	std::vector<fastjet::PseudoJet> PhaseSpacePoint::reshuffle(
	std::vector<fastjet::PseudoJet> const & Born_jets,
	fastjet::PseudoJet const & q
	){
	if(q == fastjet::PseudoJet{0, 0, 0, 0}) return Born_jets;
	const auto jets = resummation_jet_momenta(Born_jets, q);
	if(jets.empty()){
	weight_ = 0;
	return {};
	}

	// additional Jacobian to ensure Born integration over delta gives 1
	weight_ *= resummation_jet_weight(Born_jets, q);
	return jets;
	}

	std::vector<int> PhaseSpacePoint::distribute_jet_partons(
	int ng_jets, std::vector<fastjet::PseudoJet> const & jets
	){
	size_t first_valid_jet = 0;
	size_t num_valid_jets = jets.size();
	const double R_eff = 5./3.*param_.jet_param.def.R();
	// if there is an unordered jet too far away from the FKL jets
	// then extra gluon constituents of the unordered jet would
	// violate the FKL rapidity ordering
	if(unob_ && jets[0].delta_R(jets[1]) > R_eff){
	++first_valid_jet;
	--num_valid_jets;
	}
	else if(unof_ && jets[jets.size()-1].delta_R(jets[jets.size()-2]) > R_eff){
	--num_valid_jets;
	}
	std::vector<int> np(jets.size(), 1);
	for(int i = 0; i < ng_jets; ++i){
	++np[first_valid_jet + ran_.get().flat() * num_valid_jets];
	}
	weight_ *= std::pow(num_valid_jets, ng_jets);
	return np;
	}

	#ifndef NDEBUG
	namespace{
	bool tagged_FKL_backward(
	std::vector<fastjet::PseudoJet> const & jet_partons
	){
	return std::find_if(
	begin(jet_partons), end(jet_partons),
	[](fastjet::PseudoJet const & p){
	return p.user_index() == backward_FKL_idx;
	}
	) != end(jet_partons);
	}

	bool tagged_FKL_forward(
	std::vector<fastjet::PseudoJet> const & jet_partons
	){
	// the most forward FKL parton is most likely near the end of jet_partons;
	// start search from there
	return std::find_if(
	jet_partons.rbegin(), jet_partons.rend(),
	[](fastjet::PseudoJet const & p){
	return p.user_index() == forward_FKL_idx;
	}
	) != jet_partons.rend();
	}

	bool tagged_FKL_extremal(
	std::vector<fastjet::PseudoJet> const & jet_partons
	){
	return tagged_FKL_backward(jet_partons) && tagged_FKL_forward(jet_partons);
	}

	} // namespace anonymous
	#endif

	std::vector<fastjet::PseudoJet> PhaseSpacePoint::split(
	std::vector<fastjet::PseudoJet> const & jets,
	int ng_jets
	){
	return split(jets, distribute_jet_partons(ng_jets, jets));
	}

	bool PhaseSpacePoint::pass_extremal_cuts(
	fastjet::PseudoJet const & ext_parton,
	fastjet::PseudoJet const & jet
	) const{
	if(ext_parton.pt() < param_.min_extparton_pt) return false;
	return (ext_parton - jet).pt()/jet.pt() < param_.max_ext_soft_pt_fraction;
	}

	std::vector<fastjet::PseudoJet> PhaseSpacePoint::split(
	std::vector<fastjet::PseudoJet> const & jets,
	std::vector<int> const & np
	){
	assert(! jets.empty());
	assert(jets.size() == np.size());
	assert(pass_resummation_cuts(jets));

	const size_t most_backward_FKL_idx = 0 + unob_;
	const size_t most_forward_FKL_idx = jets.size() - 1 - unof_;
	const auto & jet = param_.jet_param;
	const JetSplitter jet_splitter{jet.def, jet.min_pt, ran_};

	std::vector<fastjet::PseudoJet> jet_partons;
	// randomly distribute jet gluons among jets
	for(size_t i = 0; i < jets.size(); ++i){
	auto split_res = jet_splitter.split(jets[i], np[i]);
	weight_ *= split_res.weight;
	if(weight_ == 0) return {};
	assert(
	std::all_of(
	begin(split_res.constituents), end(split_res.constituents),
	is_jet_parton
	)
	);
	const auto first_new_parton = jet_partons.insert(
	end(jet_partons),
	begin(split_res.constituents), end(split_res.constituents)
	);
	// mark uno and extremal FKL emissions here so we can check
	// their position once all emissions are generated
	auto extremal = end(jet_partons);
	if((unob_ && i == 0) \|\| i == most_backward_FKL_idx){
	// unordered or FKL backward emission
	extremal = std::min_element(
	first_new_parton, end(jet_partons), rapidity_less{}
	);
	extremal->set_user_index(
	(i == most_backward_FKL_idx)?backward_FKL_idx:unob_idx
	);
	}
	else if((unof_ && i == jets.size() - 1) \|\| i == most_forward_FKL_idx){
	// unordered or FKL forward emission
	extremal = std::max_element(
	first_new_parton, end(jet_partons), rapidity_less{}
	);
	extremal->set_user_index(
	(i == most_forward_FKL_idx)?forward_FKL_idx:unof_idx
	);
	}
	if(
	extremal != end(jet_partons)
	&& !pass_extremal_cuts(*extremal, jets[i])
	){
	weight_ = 0;
	return {};
	}
	}
	assert(tagged_FKL_extremal(jet_partons));
	std::sort(begin(jet_partons), end(jet_partons), rapidity_less{});
	if(
	!extremal_ok(jet_partons)
	\|\| !split_preserved_jets(jets, jet_partons)
	){
	weight_ = 0.;
	return {};
	}
	return jet_partons;
	}

	bool PhaseSpacePoint::extremal_ok(
	std::vector<fastjet::PseudoJet> const & partons
	) const{
	assert(std::is_sorted(begin(partons), end(partons), rapidity_less{}));
	if(unob_ && partons.front().user_index() != unob_idx) return false;
	if(unof_ && partons.back().user_index() != unof_idx) return false;
	return
	most_backward_FKL(partons).user_index() == backward_FKL_idx
	&& most_forward_FKL(partons).user_index() == forward_FKL_idx;
	}

	bool PhaseSpacePoint::split_preserved_jets(
	std::vector<fastjet::PseudoJet> const & jets,
	std::vector<fastjet::PseudoJet> const & jet_partons
	) const{
	assert(std::is_sorted(begin(jets), end(jets), rapidity_less{}));

	const auto split_jets = sorted_by_rapidity(cluster_jets(jet_partons));
	// this can happen if two overlapping jets
	// are both split into more than one parton
	if(split_jets.size() != jets.size()) return false;
	for(size_t i = 0; i < split_jets.size(); ++i){
	// this can happen if there are two overlapping jets
	// and a parton is assigned to the "wrong" jet
	if(!nearby_ep(jets[i].rapidity(), split_jets[i].rapidity(), 1e-2)){
	return false;
	}
	}
	return true;
	}

	template<class Particle>
	Particle const & PhaseSpacePoint::most_backward_FKL(
	std::vector<Particle> const & partons
	) const{
	return partons[0 + unob_];
	}

	template<class Particle>
	Particle const & PhaseSpacePoint::most_forward_FKL(
	std::vector<Particle> const & partons
	) const{
	const size_t idx = partons.size() - 1 - unof_;
	assert(idx < partons.size());
	return partons[idx];
	}

	template<class Particle>
	Particle & PhaseSpacePoint::most_backward_FKL(
	std::vector<Particle> & partons
	) const{
	return partons[0 + unob_];
	}

	template<class Particle>
	Particle & PhaseSpacePoint::most_forward_FKL(
	std::vector<Particle> & partons
	) const{
	const size_t idx = partons.size() - 1 - unof_;
	assert(idx < partons.size());
	return partons[idx];
	}

	namespace {
	bool contains_idx(
	fastjet::PseudoJet const & jet, fastjet::PseudoJet const & parton
	){
	auto const & constituents = jet.constituents();
	const int idx = parton.user_index();
	return std::find_if(
	begin(constituents), end(constituents),
	[idx](fastjet::PseudoJet const & con){return con.user_index() == idx;}
	) != end(constituents);
	}
	}

	/**
	* final jet test:
	* - number of jets must match Born kinematics
	* - no partons designated as nonjet may end up inside jets
	* - all other outgoing partons must end up inside jets
	* - the extremal (in rapidity) partons must be inside the extremal jets
	* - rapidities must be the same (by construction)
	*/
	bool PhaseSpacePoint::jets_ok(
	std::vector<fastjet::PseudoJet> const & Born_jets,
	std::vector<fastjet::PseudoJet> const & partons
	) const{
	fastjet::ClusterSequence cs(partons, param_.jet_param.def);
	const auto jets = sorted_by_rapidity(cs.inclusive_jets(param_.jet_param.min_pt));
	if(jets.size() != Born_jets.size()) return false;
	int in_jet = 0;
	for(size_t i = 0; i < jets.size(); ++i){
	assert(jets[i].has_constituents());
	for(auto && parton: jets[i].constituents()){
	if(is_nonjet_parton(parton)) return false;
	}
	in_jet += jets[i].constituents().size();
	}
	const int expect_in_jet = std::count_if(
	partons.cbegin(), partons.cend(), is_jet_parton
	);
	if(in_jet != expect_in_jet) return false;
	// note that PseudoJet::contains does not work here
	if(! (
	contains_idx(most_backward_FKL(jets), most_backward_FKL(partons))
	&& contains_idx(most_forward_FKL(jets), most_forward_FKL(partons))
	)) return false;
	if(unob_ && !contains_idx(jets.front(), partons.front())) return false;
	if(unof_ && !contains_idx(jets.back(), partons.back())) return false;
	for(size_t i = 0; i < jets.size(); ++i){
	assert(nearby_ep(jets[i].rapidity(), Born_jets[i].rapidity(), 1e-2));
	}
	return true;
	}

	void PhaseSpacePoint::reconstruct_incoming(
	std::array<Particle, 2> const & Born_incoming
	){
	std::tie(incoming_[0].p, incoming_[1].p) = incoming_momenta(outgoing_);
	for(size_t i = 0; i < incoming_.size(); ++i){
	incoming_[i].type = Born_incoming[i].type;
	}
	assert(momentum_conserved());
	}

	double PhaseSpacePoint::phase_space_normalisation(
	int num_Born_jets, int num_out_partons
	) const{
	return pow(16*pow(M_PI,3), num_Born_jets - num_out_partons);
	}

	bool PhaseSpacePoint::momentum_conserved() const{
	fastjet::PseudoJet diff;
	for(auto const & in: incoming()) diff += in.p;
	const double norm = diff.E();
	for(auto const & out: outgoing()) diff -= out.p;
	return nearby(diff, fastjet::PseudoJet{}, norm);
	}

	} //namespace HEJ
	diff --git a/src/bin/HEJ.cc b/src/bin/HEJ.cc
	index 2f70bf1..f8babc9 100644
	--- a/src/bin/HEJ.cc
	+++ b/src/bin/HEJ.cc
	@@ -1,178 +1,178 @@
	/**
	* Name: main.cc
	* Authors: Tuomas Hapola, Andreas Maier <andreas.maier@durham.ac.uk>
	*
	*/
	#include <fstream>
	#include <numeric>
	#include <memory>
	#include <chrono>
	#include <iostream>

	#include "yaml-cpp/yaml.h"

	#include "HEJ/CombinedEventWriter.hh"
	#include "HEJ/config.hh"
	#include "HEJ/EventReweighter.hh"
	#include "HEJ/get_analysis.hh"
	#include "LHEF/LHEF.h"
	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/Version.hh"
	#include "HEJ/stream.hh"
	#include "HEJ/YAMLreader.hh"
	#include "HEJ/ProgressBar.hh"
	#include "HEJ/make_RNG.hh"

	int event_number(std::string const & record){
	size_t start = record.rfind("Number of Events");
	start = record.find_first_of("123456789", start);
	if(start == std::string::npos) {
	throw std::invalid_argument("no event number record found");
	}
	const size_t end = record.find_first_not_of("0123456789", start);
	return std::stoi(record.substr(start, end - start));
	}

	HEJ::Config load_config(char const * filename){
	try{
	return HEJ::load_config(filename);
	}
	catch(std::exception const & exc){
	std::cerr << "Error: " << exc.what() << '\n';
	std::exit(EXIT_FAILURE);
	}
	}

	std::unique_ptr<HEJ::Analysis> get_analysis(
	YAML::Node const & parameters
	){
	try{
	return HEJ::get_analysis(parameters);
	}
	catch(std::exception const & exc){
	std::cerr << "Failed to load analysis: " << exc.what() << '\n';
	std::exit(EXIT_FAILURE);
	}
	}

	// unique_ptr is a workaround:
	// HEJ::optional is a better fit, but gives spurious errors with g++ 7.3.0
	std::unique_ptr<HEJ::ProgressBar<double>> make_progress_bar(
	std::vector<double> const & xs
	) {
	if(xs.empty()) return {};
	const double Born_xs = std::accumulate(begin(xs), end(xs), 0.);
	return std::make_unique<HEJ::ProgressBar<double>>(std::cout, Born_xs);
	}

	std::string time_to_string(const time_t time){
	char s[30];
	struct tm * p = localtime(&time);
	strftime(s, 30, "%a %b %d %Y %H:%M:%S", p);
	return s;
	}

	int main(int argn, char** argv) {
	using clock = std::chrono::system_clock;

	if (argn < 3) {
	std::cerr << "\n# Usage:\n."<< argv[0] <<" config_file input_file\n\n";
	return EXIT_FAILURE;
	}

	const auto start_time = clock::now();
	{
	std::cout << "Starting " << HEJ::Version::package_name_full()
	<< ", revision " << HEJ::Version::revision() << " ("
	<< time_to_string(clock::to_time_t(start_time)) << ")" << std::endl;
	}
	fastjet::ClusterSequence::print_banner();

	// read configuration
	const HEJ::Config config = load_config(argv[1]);

	HEJ::istream in{argv[2]};

	std::unique_ptr<HEJ::Analysis> analysis = get_analysis(
	config.analysis_parameters
	);
	assert(analysis != nullptr);

	LHEF::Reader reader{in};
	auto heprup = reader.heprup;
	heprup.generators.emplace_back(LHEF::XMLTag{});
	heprup.generators.back().name = HEJ::Version::package_name();
	heprup.generators.back().version = HEJ::Version::String();
	HEJ::CombinedEventWriter writer{config.output, std::move(heprup)};

	double global_reweight = 1.;
	int max_events = std::numeric_limits<int>::max();
	if(argn > 3){
	max_events = std::stoi(argv[3]);
	const int input_events = event_number(reader.headerBlock);
	global_reweight = input_events/static_cast<double>(max_events);
	std::cout << "Processing " << max_events
	<< " out of " << input_events << " events\n";
	}
	HEJ::ScaleGenerator scale_gen{
	config.scales.base,
	config.scales.factors,
	config.scales.max_ratio
	};
	auto ran = HEJ::make_RNG(config.rng.name, config.rng.seed);
	assert(ran != nullptr);
	HEJ::EventReweighter hej{
	reader.heprup,
	std::move(scale_gen),
	to_EventReweighterConfig(config),
	*ran
	};

	int nevent = 0;
	std::array<int, HEJ::event_type::last_type + 1>
	nevent_type{0}, nfailed_type{0};
	auto progress = make_progress_bar(reader.heprup.XSECUP);
	// Loop over the events in the inputfile
	while(reader.readEvent()){
	// reweight events so that the total cross section is conserved
	reader.hepeup.setWeight(0, global_reweight * reader.hepeup.weight());

	if(nevent == max_events) break;
	++nevent;

	// calculate HEJ weight
	HEJ::Event FO_event{
	HEJ::UnclusteredEvent{reader.hepeup},
	config.fixed_order_jets.def, config.fixed_order_jets.min_pt,
	};
	auto resummed_events = hej.reweight(FO_event, config.trials);
	++nevent_type[FO_event.type()];

	if(resummed_events.empty()) ++nfailed_type[FO_event.type()];

	for(auto const & ev: resummed_events){
	//TODO: move pass_cuts to after phase space point generation
	if(analysis->pass_cuts(ev, FO_event)){
	analysis->fill(ev, FO_event);
	writer.write(ev);
	}
	}
	if(progress) progress->increment(FO_event.central().weight);
	} // main event loop
	std::cout << '\n';
	analysis->finalise();

	using namespace HEJ::event_type;
	std::cout<< "Events processed: " << nevent << '\n';
	for(size_t ev_type = first_type; ev_type <= last_type; ++ev_type){
	std::cout << '\t' << names[ev_type] << ": " << nevent_type[ev_type]
	<< ", failed to reconstruct " << nfailed_type[ev_type]
	<< '\n';
	}
	std::chrono::duration<double> run_time = (clock::now() - start_time);
	std::cout << "Finished " << HEJ::Version::package_name() << " at "
	<< time_to_string(clock::to_time_t(clock::now()))
	<< "\n=> Runtime: " << run_time.count() << " sec ("
	<< nevent/run_time.count() << " Events/sec).\n";

	}
	diff --git a/src/currents.cc b/src/currents.cc
	index 817db84..7bea4da 100644
	--- a/src/currents.cc
	+++ b/src/currents.cc
	@@ -1,3617 +1,3617 @@
	//////////////////////////////////////////////////
	//////////////////////////////////////////////////
	// 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 //
	//////////////////////////////////////////////////
	//////////////////////////////////////////////////
	#include "HEJ/currents.hh"

	#include <limits>

	#include "HEJ/Constants.hh"
	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	#include "HEJ/PDG_codes.hh"

	const COM looprwfactor = (COM(0.,1.)M_PIM_PI)/pow((2.*M_PI),4);
	constexpr double infinity = std::numeric_limits<double>::infinity();

	#ifdef HEJ_BUILD_WITH_QCDLOOP
	#include "qcdloop/qcdloop.h"
	#endif

	#include <iostream>
	#include <utility>

	namespace {
	// Loop integrals
	#ifdef HEJ_BUILD_WITH_QCDLOOP

	COM B0DD(CLHEP::HepLorentzVector q, double mq)
	{
	static std::vector<std::complex<double>> result(3);
	static auto ql_B0 = [](){
	ql::Bubble<std::complex<double>,double,double> ql_B0;
	ql_B0.setCacheSize(100);
	return ql_B0;
	}();
	static std::vector<double> masses(2);
	static std::vector<double> 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<std::complex<double>> result(3);
	static auto ql_C0 = [](){
	ql::Triangle<std::complex<double>,double,double> ql_C0;
	ql_C0.setCacheSize(100);
	return ql_C0;
	}();
	static std::vector<double> masses(3);
	static std::vector<double> 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<std::complex<double>> result(3);
	static auto ql_D0 = [](){
	ql::Box<std::complex<double>,double,double> ql_D0;
	ql_D0.setCacheSize(100);
	return ql_D0;
	}();
	static std::vector<double> masses(4);
	static std::vector<double> 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];
	}

	COM A1(CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt)
	// As given in Eq. (B.2) of VDD
	{
	double q12,q22,Q2;
	CLHEP::HepLorentzVector Q;
	double Delta3,mt2;
	COM ans(COM(0.,0.));

	q12=q1.m2();
	q22=q2.m2();
	Q=-q1-q2; // Define all momenta ingoing as in appendix of VDD
	Q2=Q.m2();

	Delta3=q12q12+q22q22+Q2Q2-2q12q22-2q12Q2-2q22*Q2;
	if (mt < 0.)
	std::cerr<<"Problem in A1! mt = "<<mt<<std::endl;
	mt2=mt*mt;

	ans=looprwfactorCOM(0,-1)C0DD(q1,q2,mt)( 4.mt2/Delta3*(Q2-q12-q22)
	-1.-4.q12q22/Delta3-12.q12q22Q2/Delta3/Delta3(q12+q22-Q2) )
	- looprwfactorCOM(0,-1)( B0DD(q2,mt)-B0DD(Q,mt) )
	* ( 2.q22/Delta3+12.q12q22/Delta3/Delta3(q22-q12+Q2) )
	- looprwfactorCOM(0,-1)( B0DD(q1,mt)-B0DD(Q,mt) )
	* ( 2.q12/Delta3+12.q12q22/Delta3/Delta3(q12-q22+Q2) )
	- 2./Delta3/16/M_PI/M_PI*(q12+q22-Q2);

	return ans;

	}


	COM A2(CLHEP::HepLorentzVector q1, CLHEP::HepLorentzVector q2, double mt)
	// As given in Eq. (B.2) of VDD, but with high energy limit
	// of invariants taken.
	{
	double q12,q22,Q2;
	CLHEP::HepLorentzVector Q;
	double Delta3,mt2;
	COM ans(COM(0.,0.));

	if (mt < 0.)
	std::cerr<<"Problem in A2! mt = "<<mt<<std::endl;
	mt2=mt*mt;

	q12=q1.m2();
	q22=q2.m2();
	Q=-q1-q2; // Define all momenta ingoing as in appendix of VDD
	Q2=Q.m2();

	Delta3=q12q12+q22q22+Q2Q2-2q12q22-2q12Q2-2q22*Q2;
	ans=looprwfactorCOM(0,-1)C0DD(q1,q2,mt)( 2.mt2+1./2.*(q12+q22-Q2)
	+2.q12q22*Q2/Delta3 )
	+looprwfactorCOM(0,-1)(B0DD(q2,mt)-B0DD(Q,mt))
	q22(q22-q12-Q2)/Delta3
	+looprwfactorCOM(0,-1)(B0DD(q1,mt)-B0DD(Q,mt))
	q12(q12-q22-Q2)/Delta3+1./16/M_PI/M_PI;

	return ans;
	}

	#else // no QCDloop

	COM A1(CLHEP::HepLorentzVector, CLHEP::HepLorentzVector, double) {
	throw std::logic_error{"A1 called without QCDloop support"};
	}

	COM A2(CLHEP::HepLorentzVector, CLHEP::HepLorentzVector, double) {
	throw std::logic_error{"A2 called without QCDloop support"};
	}

	#endif

	void to_current(const CLHEP::HepLorentzVector & q, current & ret){
	ret[0]=q.e();
	ret[1]=q.x();
	ret[2]=q.y();
	ret[3]=q.z();
	}

	constexpr double C_A = 3.;
	constexpr double C_F = 4./3.;
	using ParticleID = HEJ::pid::ParticleID;

	// Colour acceleration multiplier for gluons see eq. (7) in arXiv:0910.5113
	// TODO: this is not a current and should be moved somewhere else
	double K_g(double p1minus, double paminus) {
	return 1./2.(p1minus/paminus + paminus/p1minus)(C_A - 1./C_A) + 1./C_A;
	}
	double K_g(
	CLHEP::HepLorentzVector const & pout,
	CLHEP::HepLorentzVector const & pin
	) {
	if(pin.z() > 0) return K_g(pout.plus(), pin.plus());
	return K_g(pout.minus(), pin.minus());
	}

	} // namespace anonymous

	/// @TODO move all of these functions to header? clean up in general
	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];
	}

	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();
	}

	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!?!
	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];
	}

	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];
	}

	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];
	}

	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];
	}

	double abs2(const COM & a)
	{
	return (a*conj(a)).real();
	}

	double vabs2(const CCurrent & cur)
	{
	return abs2(cur.c0)-abs2(cur.c1)-abs2(cur.c2)-abs2(cur.c3);
	}

	double vre(const CCurrent & a, const CCurrent & b)
	{
	return real(a.c0conj(b.c0)-a.c1conj(b.c1)-a.c2conj(b.c2)-a.c3conj(b.c3));
	}

	CCurrent CCurrent::operator+(const CCurrent& other)
	{
	COM result_c0=c0 + other.c0;
	COM result_c1=c1 + other.c1;
	COM result_c2=c2 + other.c2;
	COM result_c3=c3 + other.c3;

	return CCurrent(result_c0,result_c1,result_c2,result_c3);
	}

	CCurrent CCurrent::operator-(const CCurrent& other)
	{
	COM result_c0=c0 - other.c0;
	COM result_c1=c1 - other.c1;
	COM result_c2=c2 - other.c2;
	COM result_c3=c3 - other.c3;

	return CCurrent(result_c0,result_c1,result_c2,result_c3);
	}

	CCurrent CCurrent::operator*(const double x)
	{
	COM result_c0=x*CCurrent::c0;
	COM result_c1=x*CCurrent::c1;
	COM result_c2=x*CCurrent::c2;
	COM result_c3=x*CCurrent::c3;

	return CCurrent(result_c0,result_c1,result_c2,result_c3);
	}

	CCurrent CCurrent::operator/(const double x)
	{
	COM result_c0=CCurrent::c0/x;
	COM result_c1=CCurrent::c1/x;
	COM result_c2=CCurrent::c2/x;
	COM result_c3=CCurrent::c3/x;

	return CCurrent(result_c0,result_c1,result_c2,result_c3);
	}

	CCurrent CCurrent::operator*(const COM x)
	{
	COM result_c0=x*CCurrent::c0;
	COM result_c1=x*CCurrent::c1;
	COM result_c2=x*CCurrent::c2;
	COM result_c3=x*CCurrent::c3;

	return CCurrent(result_c0,result_c1,result_c2,result_c3);
	}

	CCurrent CCurrent::operator/(const COM x)
	{
	COM result_c0=(CCurrent::c0)/x;
	COM result_c1=(CCurrent::c1)/x;
	COM result_c2=(CCurrent::c2)/x;
	COM result_c3=(CCurrent::c3)/x;

	return CCurrent(result_c0,result_c1,result_c2,result_c3);
	}

	std::ostream& operator <<(std::ostream& os, const CCurrent& cur)
	{
	os << "("<<cur.c0<< " ; "<<cur.c1<<" , "<<cur.c2<<" , "<<cur.c3<<")";
	return os;
	}

	CCurrent operator * ( double x, CCurrent& m)
	{
	return m*x;
	}

	CCurrent operator * ( COM x, CCurrent& m)
	{
	return m*x;
	}

	CCurrent operator / ( double x, CCurrent& m)
	{
	return m/x;
	}

	CCurrent operator / ( COM x, CCurrent& m)
	{
	return m/x;
	}

	COM CCurrent::dot(CLHEP::HepLorentzVector p1)
	{
	// Current goes (E,px,py,pz)
	// std::cout<<"current = ("<<c0<<","<<c1<<","<<c2<<","<<c3<<")\n";
	// Vector goes (px,py,pz,E)
	// std::cout<<"vector = ("<<p1[0]<<","<<p1[1]<<","<<p1[2]<<","<<p1[3]<<")\n";
	return p1[3]c0-p1[0]c1-p1[1]c2-p1[2]c3;
	}

	COM CCurrent::dot(CCurrent p1)
	{
	return p1.c0c0-p1.c1c1-p1.c2c2-p1.c3c3;
	}

	//Current Functions

	// Current for <outgoing state \| mu \| incoming state>
	/// @TODO always use this instead of "j"
	/// @TODO isn't this jio with flipt helicities?
	void joi(HLV pout, bool helout, HLV pin, bool helin, current &cur) {
	cur[0]=0.;
	cur[1]=0.;
	cur[2]=0.;
	cur[3]=0.;

	const double sqpop = sqrt(pout.plus());
	const double sqpom = sqrt(pout.minus());
	const COM poperp = pout.x() + COM(0, 1) * pout.y();

	if (helout != helin) {
	throw std::invalid_argument{"Non-matching helicities"};
	} else if (helout == false) { // negative helicity
	if (pin.plus() > pin.minus()) { // if forward
	const 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
	const 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
	const 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
	const 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 joi (HLV pout, bool helout, HLV pin, bool helin)
	{
	current cur;
	joi(pout, helout, pin, helin, cur);
	return CCurrent(cur[0],cur[1],cur[2],cur[3]);
	}

	/// @TODO remove this
	void j (HLV pout, bool helout, HLV pin, bool helin,current &cur) {
	joi(pout, helout, pin, helin, cur);
	}

	/// @TODO remove this
	CCurrent j (HLV pout, bool helout, HLV pin, bool helin)
	{
	return joi(pout, helout, pin, helin);
	}


	// Current for <incoming state \| mu \| outgoing state>
	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;
	const double sqpop = sqrt(pout.plus());
	const double sqpom = sqrt(pout.minus());
	const COM poperp = pout.x() + COM(0, 1) * pout.y();


	if (helout != helin) {
	throw std::invalid_argument{"Non-matching helicities"};
	} else if (helout == false) { // negative helicity
	if (pin.plus() > pin.minus()) { // if forward
	const 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
	const 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
	const 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
	const 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 jio (HLV pin, bool helin, HLV pout, bool helout)
	{
	current cur;
	jio(pin, helin, pout, helout, cur);
	return CCurrent(cur[0],cur[1],cur[2],cur[3]);
	}


	// Current for <outgoing state \| mu \| outgoing state>
	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 (heli!=helj) {
	throw std::invalid_argument{"Non-matching helicities"};
	} else if ( heli == true ) { // If positive helicity swap momenta
	std::swap(pi,pj);
	}

	const double sqpjp = sqrt(pj.plus());
	const double sqpjm = sqrt(pj.minus());
	const double sqpip = sqrt(pi.plus());
	const double sqpim = sqrt(pi.minus());

	const COM piperp = pi.x() + COM(0,1) * pi.y();
	const COM pjperp = pj.x() + COM(0,1) * pj.y();
	const COM phasei = piperp / abs(piperp);
	const COM phasej = pjperp / abs(pjperp);

	cur[0] = sqpim * sqpjm * phasei * conj(phasej) + sqpip * sqpjp;
	cur[1] = sqpim * sqpjp * phasei + sqpip * sqpjm * conj(phasej);
	cur[2] = -COM(0, 1) * (sqpim * sqpjp * phasei - sqpip * sqpjm * conj(phasej));
	cur[3] = -sqpim * sqpjm * phasei * conj(phasej) + sqpip * sqpjp;
	}

	CCurrent joo (HLV pi, bool heli, HLV pj, bool helj)
	{
	current cur;
	joo(pi, heli, pj, helj, cur);
	return CCurrent(cur[0],cur[1],cur[2],cur[3]);
	}

	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 : ("<<C1[0]<<","<<C1[1]<<","<<C1[2]<<","<<C1[3]<<"\n";
	// std::cout << "# From Currents, C2 : ("<<C2[0]<<","<<C2[1]<<","<<C2[2]<<","<<C2[3]<<"\n";

	// COM M=cdot(C1,C2);

	// return (Mconj(M)).real()/(q1.m2()q2.m2());
	// }

	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)!!
	// 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);
	joi(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);
	joi(pnu,helnu,pin,helin,temp3);
	joi(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.brac615Current(pout,helout,pin,helin)+prod1565Current(pe,helin,pin,helin)+prod1665Current(pnu,helin,pin,helin))/ta + (2.brac645Current(pout,helout,pin,helin)-prod5465CurrentOutOut(pout,helout,pe,helout)-prod6465CurrentOutOut(pout,helout,pnu,helout))/tb);
	// cur=((2.brac615temp5+prod1565temp3+prod1665temp4)/ta + (2.brac645temp5-prod5465temp1-prod6465temp2)/tb);
	cadd(term1,term2,term3,sum);
	// std::cout<<"sum: ("<<sum[0]<<","<<sum[1]<<","<<sum[2]<<","<<sum[3]<<")\n";
	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);

	// cur=((2.brac615Current(pout,helout,pin,helin)+prod1565Current(pe,helin,pin,helin)+prod1665Current(pnu,helin,pin,helin))/ta + (2.brac645Current(pout,helout,pin,helin)-prod5465CurrentOutOut(pout,helout,pe,helout)-prod6465CurrentOutOut(pout,helout,pnu,helout))/tb);
	// cur=((2.brac615temp5+prod1565temp3+prod1665temp4)/ta + (2.brac645temp5-prod5465temp1-prod6465temp2)/tb);
	cadd(term1,term2,term3,sum);
	// std::cout<<"term1: ("<<temp5[0]<<" "<<temp5[1]<<" "<<temp5[2]<<" "<<temp5[3]<<")"<<std::endl;
	// std::cout<<"sum: ("<<sum[0]<<","<<sum[1]<<","<<sum[2]<<","<<sum[3]<<")\n";
	cur[0]=sum[0];
	cur[1]=sum[1];
	cur[2]=sum[2];
	cur[3]=sum[3];
	}
	}
	} // namespace anonymous

	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);
	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	// std::cout<<"jMW1: ("<<mj1m[0]<<","<<mj1m[1]<<","<<mj1m[2]<<","<<mj1m[3]<<")\n";
	// std::cout<<"jMW2: ("<<mj2p[0]<<","<<mj2p[1]<<","<<mj2p[2]<<","<<mj2p[3]<<")\n";
	// std::cout<<"jMW3: ("<<mj2m[0]<<","<<mj2m[1]<<","<<mj2m[2]<<","<<mj2m[3]<<")\n";

	// 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);

	// std::cout<<"jMW1: ("<<mj1m[0]<<","<<mj1m[1]<<","<<mj1m[2]<<","<<mj1m[3]<<")\n";
	// std::cout<<"jMW2: ("<<mj2p[0]<<","<<mj2p[1]<<","<<mj2p[2]<<","<<mj2p[3]<<")\n";
	// std::cout<<"jMW3: ("<<mj2m[0]<<","<<mj2m[1]<<","<<mj2m[2]<<","<<mj2m[3]<<")\n";

	// 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);
	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	// std::cout<<"jMW1: ("<<mj1m[0]<<","<<mj1m[1]<<","<<mj1m[2]<<","<<mj1m[3]<<")\n";
	// std::cout<<"jMW2: ("<<mj2p[0]<<","<<mj2p[1]<<","<<mj2p[2]<<","<<mj2p[3]<<")\n";
	// std::cout<<"jMW3: ("<<mj2m[0]<<","<<mj2m[1]<<","<<mj2m[2]<<","<<mj2m[3]<<")\n";

	// 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);

	// std::cout<<"jMW1: ("<<mj1m[0]<<","<<mj1m[1]<<","<<mj1m[2]<<","<<mj1m[3]<<")\n";
	// std::cout<<"jMW2: ("<<mj2p[0]<<","<<mj2p[1]<<","<<mj2p[2]<<","<<mj2p[3]<<")\n";
	// std::cout<<"jMW3: ("<<mj2m[0]<<","<<mj2m[1]<<","<<mj2m[2]<<","<<mj2m[3]<<")\n";

	// 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);

	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	// mj1m.mj2p

	COM Mmp=cdot(mj1m,mj2p);

	// mj1m.mj2m
	COM Mmm=cdot(mj1m,mj2m);

	const double K = K_g(p2out, p2in);

	// sum of spinor strings \|\|^2
	double a2Mmp=abs2(Mmp);
	double a2Mmm=abs2(Mmm);
	double sst = K/C_A*(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);

	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	// mj1m.mj2p

	COM Mmp=cdot(mj1m,mj2p);

	// mj1m.mj2m
	COM Mmm=cdot(mj1m,mj2m);

	const double K = K_g(p2out, p2in);

	// sum of spinor strings \|\|^2
	double a2Mmp=abs2(Mmp);
	double a2Mmm=abs2(Mmm);
	double sst = K/C_A*(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: "<<p1out<<" "<<p1in<<" "<<p2out<<" "<<p2in<<std::endl;

	CLHEP::HepLorentzVector q1=p1in-p1out;
	CLHEP::HepLorentzVector q2=-(p2in-p2out);
	// std::cerr<<"Current: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	current mj1m,mj1p,mj2m,mj2p;
	joi(p1out,true,p1in,true,mj1p);
	joi(p1out,false,p1in,false,mj1m);
	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	COM Mmp=cdot(mj1m,mj2p);
	COM Mmm=cdot(mj1m,mj2m);
	COM Mpp=cdot(mj1p,mj2p);
	COM Mpm=cdot(mj1p,mj2m);

	double sst=abs2(Mmm)+abs2(Mmp)+abs2(Mpp)+abs2(Mpm);

	// Multiply by Cf^2
	return HEJ::C_FHEJ::C_F(sst)/(q1.m2()*q2.m2());
	}

	double jM2qQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in)
	{
	CLHEP::HepLorentzVector q1=p1in-p1out;
	CLHEP::HepLorentzVector q2=-(p2in-p2out);
	current mj1m,mj1p,mj2m,mj2p;
	joi(p1out,true,p1in,true,mj1p);
	joi(p1out,false,p1in,false,mj1m);
	jio(p2in,true,p2out,true,mj2p);
	jio(p2in,false,p2out,false,mj2m);

	COM Mmp=cdot(mj1m,mj2p);
	COM Mmm=cdot(mj1m,mj2m);
	COM Mpp=cdot(mj1p,mj2p);
	COM Mpm=cdot(mj1p,mj2m);

	double sumsq=abs2(Mmm)+abs2(Mmp)+abs2(Mpp)+abs2(Mpm);

	// Multiply by Cf^2
	return (4./3.)(4./3.)(sumsq)/(q1.m2()*q2.m2());
	}

	double jM2qbarQbar (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in)
	{
	CLHEP::HepLorentzVector q1=p1in-p1out;
	CLHEP::HepLorentzVector q2=-(p2in-p2out);
	current mj1m,mj1p,mj2m,mj2p;
	jio(p1in,true,p1out,true,mj1p);
	jio(p1in,false,p1out,false,mj1m);
	jio(p2in,true,p2out,true,mj2p);
	jio(p2in,false,p2out,false,mj2m);

	COM Mmp=cdot(mj1m,mj2p);
	COM Mmm=cdot(mj1m,mj2m);
	COM Mpp=cdot(mj1p,mj2p);
	COM Mpm=cdot(mj1p,mj2m);

	double sumsq=abs2(Mmm)+abs2(Mmp)+abs2(Mpp)+abs2(Mpm);

	// Multiply by Cf^2
	return (4./3.)(4./3.)(sumsq)/(q1.m2()*q2.m2());
	}

	double jM2qg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in)
	// Calculates the square of the current contractions for qg scattering
	// p1: quark
	// p2: gluon
	{
	CLHEP::HepLorentzVector q1=p1in-p1out;
	CLHEP::HepLorentzVector q2=-(p2in-p2out);

	current mj1m,mj1p,mj2m,mj2p;
	joi(p1out,true,p1in,true,mj1p);
	joi(p1out,false,p1in,false,mj1m);
	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	COM Mmp=cdot(mj1m,mj2p);
	COM Mmm=cdot(mj1m,mj2m);
	COM Mpp=cdot(mj1p,mj2p);
	COM Mpm=cdot(mj1p,mj2m);

	const double K = K_g(p2out, p2in);

	// sum of spinor strings \|\|^2
	double a2Mmp=abs2(Mmp);
	double a2Mmm=abs2(Mmm);
	double a2Mpp=abs2(Mpp);
	double a2Mpm=abs2(Mpm);
	double sst = K/C_A*(a2Mpp+a2Mpm+a2Mmp+a2Mmm);
	// double sstsave=sst;

	// std::cout <<"ratio: "<<sst/sstsave<<std::endl;
	// Cf*Ca=4
	return 4.sst/(q1.m2()q2.m2());

	}

	double jM2qbarg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in)
	// Calculates the square of the current contractions for qg scattering
	// p1: quark
	// p2: gluon
	{
	CLHEP::HepLorentzVector q1=p1in-p1out;
	CLHEP::HepLorentzVector q2=-(p2in-p2out);

	current mj1m,mj1p,mj2m,mj2p;
	jio(p1in,true,p1out,true,mj1p);
	jio(p1in,false,p1out,false,mj1m);
	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	COM Mmp=cdot(mj1m,mj2p);
	COM Mmm=cdot(mj1m,mj2m);
	COM Mpp=cdot(mj1p,mj2p);
	COM Mpm=cdot(mj1p,mj2m);

	const double K = K_g(p2out, p2in);

	// sum of spinor strings \|\|^2
	double a2Mmp=abs2(Mmp);
	double a2Mmm=abs2(Mmm);
	double a2Mpp=abs2(Mpp);
	double a2Mpm=abs2(Mpm);
	double sst = K/C_A*(a2Mpp+a2Mpm+a2Mmp+a2Mmm);
	// double sstsave=sst;

	// std::cout <<"ratio: "<<sst/sstsave<<std::endl;
	// Cf*Ca=4
	return 4.sst/(q1.m2()q2.m2());

	}

	double jM2gg (CLHEP::HepLorentzVector p1out, CLHEP::HepLorentzVector p1in, CLHEP::HepLorentzVector p2out, CLHEP::HepLorentzVector p2in)
	// Calculates the square of the current contractions for gg scattering
	// p1: gluon
	// p2: gluon
	{
	CLHEP::HepLorentzVector q1=p1in-p1out;
	CLHEP::HepLorentzVector q2=-(p2in-p2out);

	current mj1m,mj1p,mj2m,mj2p;
	joi(p1out,true,p1in,true,mj1p);
	joi(p1out,false,p1in,false,mj1m);
	joi(p2out,true,p2in,true,mj2p);
	joi(p2out,false,p2in,false,mj2m);

	COM Mmp=cdot(mj1m,mj2p);
	COM Mmm=cdot(mj1m,mj2m);
	COM Mpp=cdot(mj1p,mj2p);
	COM Mpm=cdot(mj1p,mj2m);

	const double K_g1 = K_g(p1out, p1in);
	const double K_g2 = K_g(p2out, p2in);

	// sum of spinor strings \|\|^2
	double a2Mmp=abs2(Mmp);
	double a2Mmm=abs2(Mmm);
	double a2Mpp=abs2(Mpp);
	double a2Mpm=abs2(Mpm);
	double sst = K_g1/C_AK_g2/C_A(a2Mpp+a2Mpm+a2Mmp+a2Mmm);
	// double sstsave=sst;
	// std::cout <<"ratio: "<<sst/sstsave<<std::endl;
	// Ca*Ca=9
	return 9.sst/(q1.m2()q2.m2());

	}

	namespace {
	/// @TODO what was this intended to do?
	// double MH2helper(current C1, current C2, current q1, current q2)
	// {
	// COM M;
	// COM temp1,temp2;
	// // First the C1.q2 * C2.q1 - part
	// temp1=cdot(C1,q2);
	// temp2=cdot(C2,q1);
	// M=temp1*temp2;

	// // Then the C1.C2 * q1.q2
	// temp1=cdot(C1,C2);
	// temp2=cdot(q1,q2);
	// M-=temp1*temp2;

	// return (M*conj(M)).real();
	// }

	/**
	* @brief Higgs vertex contracted with current @param C1 and @param C2
	*/
	COM cHdot(const current & C1, const current & C2, const current & q1,
	const current & q2, double mt, bool incBot, double mb)
	{
	if (mt == infinity) {
	return (cdot(C1,C2)cdot(q1,q2)-cdot(C1,q2)cdot(C2,q1))/(6M_PIHEJ::vev);
	}
	else {
	CLHEP::HepLorentzVector vq1,vq2;
	vq1.set(q1[1].real(),q1[2].real(),q1[3].real(),q1[0].real());
	vq2.set(q2[1].real(),q2[2].real(),q2[3].real(),q2[0].real());
	// first minus sign obtained because of q1-difference to VDD
	// std::cout<<"A1 : " << A1(-vq1,vq2)<<std::endl;
	// std::cout<<"A2 : " << A2(-vq1,vq2)<<std::endl;
	if(!(incBot))
	// Factor is because 4 mt^2 g^2/HEJ::vev A1 -> 16 pi mt^2/HEJ::vev alphas,
	// and we divide by a factor 4 at the amp sqaured level later
	// which I absorb here (i.e. I divide by 2)
	/// @TODO move factor 1/2 from S to \|ME\|^2 => consistent with general notation
	return 8.M_PImtmt/HEJ::vev(-cdot(C1,q2)cdot(C2,q1)A1(-vq1,vq2,mt)-cdot(C1,C2)*A2(-vq1,vq2,mt));
	else
	return 8.M_PImtmt/HEJ::vev(-cdot(C1,q2)cdot(C2,q1)A1(-vq1,vq2,mt)-cdot(C1,C2)*A2(-vq1,vq2,mt))
	+ 8.M_PImbmb/HEJ::vev(-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;

	joi (p1out,true,p1in,true,j1p);
	joi (p1out,false,p1in,false,j1m);

	joi (p2out,true,p2in,true,j2p);
	joi (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;

	joi (p1out,true,p1in,true,j1p);
	joi (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);

	joi (p2out,true,p2in,true,j2p);
	joi (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;

	joi (p1out,true,p1in,true,j1p);
	joi (p1out,false,p1in,false,j1m);

	joi (p2out,true,p2in,true,j2p);
	joi (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;

	const double K = K_g(p2out, p2in);

	double sst=K/C_A*(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);

	joi (p2out,true,p2in,true,j2p);
	joi (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);

	const double K = K_g(p2out, p2in);
	MH2sum*=K/C_A;

	// 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;

	joi (p1out,true,p1in,true,j1p);
	joi (p1out,false,p1in,false,j1m);

	joi (p2out,true,p2in,true,j2p);
	joi (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);

	const double K_g1 = K_g(p1out, p1in);
	const double K_g2 = K_g(p2out, p2in);

	MH2sum=K_g1/C_AK_g2/C_A;

	// 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 <double> jMZqQ (HLV pa, HLV pb, HLV p1, HLV p2, HLV pep, HLV pem, std::vector <double> VProducts, std::vector < std::vector <double> > Virtuals, int aptype, int bptype, bool UseVirtuals, bool BottomLineEmit) {

	// std::vector <double> 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 <double> jMZqg (HLV pa, HLV pb, HLV p1, HLV p2, HLV pep, HLV pem, std::vector <double> VProducts, std::vector < std::vector <double> > Virtuals, int aptype, int bptype, bool UseVirtuals, bool BottomLineEmit) {

	// COM Coeff[8];

	// double Sum;

	// std::vector <double> 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 {

	//@{
	/// @brief Higgs vertex contracted with one current

	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 = joi(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)/(3M_PIHEJ::vev);
	else
	{
	if(incBot)
	return (-16.M_PImbmb/HEJ::vevj2.dot(q1)jq2A1(-q1,q2,mb)-16.M_PImbmb/HEJ::vevj2*A2(-q1,q2,mb))
	+ (-16.M_PImtmt/HEJ::vevj2.dot(q1)jq2A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj2*A2(-q1,q2,mt));
	else
	return (-16.M_PImtmt/HEJ::vevj2.dot(q1)jq2A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj2*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)/(3M_PIHEJ::vev);
	else
	{
	if(incBot)
	return (-16.M_PImbmb/HEJ::vevj2.dot(q1)jq2A1(-q1,q2,mb)-16.M_PImbmb/HEJ::vevj2*A2(-q1,q2,mb))
	+ (-16.M_PImtmt/HEJ::vevj2.dot(q1)jq2A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj2*A2(-q1,q2,mt));
	else
	return (-16.M_PImtmt/HEJ::vevj2.dot(q1)jq2A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj2*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 = joi(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)/(3M_PIHEJ::vev);
	else
	{
	if(incBot)
	return (-16.M_PImbmb/HEJ::vevj1.dot(q2)jq1A1(-q1,q2,mb)-16.M_PImbmb/HEJ::vevj1*A2(-q1,q2,mb))
	+ (-16.M_PImtmt/HEJ::vevj1.dot(q2)jq1A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj1*A2(-q1,q2,mt));
	else
	return (-16.M_PImtmt/HEJ::vevj1.dot(q2)jq1A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj1*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)/(3M_PIHEJ::vev);
	else
	{
	if(incBot)
	return (-16.M_PImbmb/HEJ::vevj1.dot(q2)jq1A1(-q1,q2,mb)-16.M_PImbmb/HEJ::vevj1*A2(-q1,q2,mb))
	+ (-16.M_PImtmt/HEJ::vevj1.dot(q2)jq1A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj1*A2(-q1,q2,mt));
	else
	return (-16.M_PImtmt/HEJ::vevj1.dot(q2)jq1A1(-q1,q2,mt)-16.M_PImtmt/HEJ::vevj1*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: "<<p1out<<" "<<p1in<<" "<<p2out<<" "<<p2in<<" "<<pg<<std::endl;

	CLHEP::HepLorentzVector q1=p1in-p1out; // Top End
	CLHEP::HepLorentzVector q2=-(p2in-p2out); // Bottom End
	CLHEP::HepLorentzVector qg=p1in-p1out-pg; // Extra bit post-gluon

	// std::cerr<<"Current: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mj1m,mj1p,mj2m,mj2p,mjH2m,mjH2p;
	mj1p=joi(p1out,true,p1in,true);
	mj1m=joi(p1out,false,p1in,false);
	mjH2p=jH(p2out,true,p2in,true,qH1,qH2, mt, incBot, mb);
	mjH2m=jH(p2out,false,p2in,false,qH1,qH2, mt, incBot, mb);

	// Dot products of these which occur again and again
	COM MHmp=mj1m.dot(mjH2p); // And now for the Higgs ones
	COM MHmm=mj1m.dot(mjH2m);
	COM MHpp=mj1p.dot(mjH2p);
	COM MHpm=mj1p.dot(mjH2m);

	// std::cout<< p1out.rapidity() << " " << p2out.rapidity()<< " " << qH1 << " " << qH2 << "\n" <<MHmm << " " << MHmp << " " << MHpm << " " << MHpp << std::endl;

	// Currents with pg
	CCurrent jgam,jgap,j2gm,j2gp;
	j2gp=joo(p1out,true,pg,true);
	j2gm=joo(p1out,false,pg,false);
	jgap=joi(pg,true,p1in,true);
	jgam=joi(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(MHmm) + (-2.mjH2m.dot(pg))mj1m+2.mj1m.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmm/2.))/q1.m2();
	Lmp=(qsum(MHmp) + (-2.mjH2p.dot(pg))mj1m+2.mj1m.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmp/2.))/q1.m2();
	Lpm=(qsum(MHpm) + (-2.mjH2m.dot(pg))mj1p+2.mj1p.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpm/2.))/q1.m2();
	Lpp=(qsum(MHpp) + (-2.mjH2p.dot(pg))mj1p+2.mj1p.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpp/2.))/q1.m2();

	U1mm=(jgam.dot(mjH2m)j2gm+2.p1o*MHmm)/(p1out+pg).m2();
	U1mp=(jgam.dot(mjH2p)j2gm+2.p1o*MHmp)/(p1out+pg).m2();
	U1pm=(jgap.dot(mjH2m)j2gp+2.p1o*MHpm)/(p1out+pg).m2();
	U1pp=(jgap.dot(mjH2p)j2gp+2.p1o*MHpp)/(p1out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH2m)jgam+2.p1iMHmm)/(p1in-pg).m2();
	U2mp=((-1.)j2gm.dot(mjH2p)jgam+2.p1iMHmp)/(p1in-pg).m2();
	U2pm=((-1.)j2gp.dot(mjH2m)jgap+2.p1iMHpm)/(p1in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH2p)jgap+2.p1iMHpp)/(p1in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q2.m2()*qH2.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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=HEJ::C_FHEJ::C_F/HEJ::C_A/HEJ::C_A; // 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: "<<p1out<<" "<<p1in<<" "<<p2out<<" "<<p2in<<" "<<pg<<std::endl;

	CLHEP::HepLorentzVector q1=p1in-p1out; // Top End
	CLHEP::HepLorentzVector q2=-(p2in-p2out); // Bottom End
	CLHEP::HepLorentzVector qg=p1in-p1out-pg; // Extra bit post-gluon

	// std::cerr<<"Current: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mj1m,mj1p,mj2m,mj2p,mjH2m,mjH2p;
	mj1p=jio(p1in,true,p1out,true);
	mj1m=jio(p1in,false,p1out,false);
	mjH2p=jH(p2out,true,p2in,true,qH1,qH2, mt, incBot, mb);
	mjH2m=jH(p2out,false,p2in,false,qH1,qH2, mt, incBot, mb);

	// Dot products of these which occur again and again
	COM MHmp=mj1m.dot(mjH2p); // And now for the Higgs ones
	COM MHmm=mj1m.dot(mjH2m);
	COM MHpp=mj1p.dot(mjH2p);
	COM MHpm=mj1p.dot(mjH2m);

	// Currents with pg
	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(MHmm) + (-2.mjH2m.dot(pg))mj1m+2.mj1m.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmm/2.))/q1.m2();
	Lmp=(qsum(MHmp) + (-2.mjH2p.dot(pg))mj1m+2.mj1m.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmp/2.))/q1.m2();
	Lpm=(qsum(MHpm) + (-2.mjH2m.dot(pg))mj1p+2.mj1p.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpm/2.))/q1.m2();
	Lpp=(qsum(MHpp) + (-2.mjH2p.dot(pg))mj1p+2.mj1p.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpp/2.))/q1.m2();

	U1mm=(jgam.dot(mjH2m)j2gm+2.p1o*MHmm)/(p1out+pg).m2();
	U1mp=(jgam.dot(mjH2p)j2gm+2.p1o*MHmp)/(p1out+pg).m2();
	U1pm=(jgap.dot(mjH2m)j2gp+2.p1o*MHpm)/(p1out+pg).m2();
	U1pp=(jgap.dot(mjH2p)j2gp+2.p1o*MHpp)/(p1out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH2m)jgam+2.p1iMHmm)/(p1in-pg).m2();
	U2mp=((-1.)j2gm.dot(mjH2p)jgam+2.p1iMHmp)/(p1in-pg).m2();
	U2pm=((-1.)j2gp.dot(mjH2m)jgap+2.p1iMHpm)/(p1in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH2p)jgap+2.p1iMHpp)/(p1in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q2.m2()*qH2.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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: "<<p1out<<" "<<p1in<<" "<<p2out<<" "<<p2in<<" "<<pg<<std::endl;

	CLHEP::HepLorentzVector q1=p1in-p1out; // Top End
	CLHEP::HepLorentzVector q2=-(p2in-p2out); // Bottom End
	CLHEP::HepLorentzVector qg=p1in-p1out-pg; // Extra bit post-gluon

	// std::cerr<<"Current: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mj1m,mj1p,mj2m,mj2p,mjH2m,mjH2p;
	mj1p=joi(p1out,true,p1in,true);
	mj1m=joi(p1out,false,p1in,false);
	mjH2p=jioH(p2in,true,p2out,true,qH1,qH2, mt, incBot, mb);
	mjH2m=jioH(p2in,false,p2out,false,qH1,qH2, mt, incBot, mb);

	// Dot products of these which occur again and again
	COM MHmp=mj1m.dot(mjH2p); // And now for the Higgs ones
	COM MHmm=mj1m.dot(mjH2m);
	COM MHpp=mj1p.dot(mjH2p);
	COM MHpm=mj1p.dot(mjH2m);

	// Currents with pg
	CCurrent jgam,jgap,j2gm,j2gp;
	j2gp=joo(p1out,true,pg,true);
	j2gm=joo(p1out,false,pg,false);
	jgap=joi(pg,true,p1in,true);
	jgam=joi(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(MHmm) + (-2.mjH2m.dot(pg))mj1m+2.mj1m.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmm/2.))/q1.m2();
	Lmp=(qsum(MHmp) + (-2.mjH2p.dot(pg))mj1m+2.mj1m.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmp/2.))/q1.m2();
	Lpm=(qsum(MHpm) + (-2.mjH2m.dot(pg))mj1p+2.mj1p.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpm/2.))/q1.m2();
	Lpp=(qsum(MHpp) + (-2.mjH2p.dot(pg))mj1p+2.mj1p.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpp/2.))/q1.m2();

	U1mm=(jgam.dot(mjH2m)j2gm+2.p1o*MHmm)/(p1out+pg).m2();
	U1mp=(jgam.dot(mjH2p)j2gm+2.p1o*MHmp)/(p1out+pg).m2();
	U1pm=(jgap.dot(mjH2m)j2gp+2.p1o*MHpm)/(p1out+pg).m2();
	U1pp=(jgap.dot(mjH2p)j2gp+2.p1o*MHpp)/(p1out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH2m)jgam+2.p1iMHmm)/(p1in-pg).m2();
	U2mp=((-1.)j2gm.dot(mjH2p)jgam+2.p1iMHmp)/(p1in-pg).m2();
	U2pm=((-1.)j2gp.dot(mjH2m)jgap+2.p1iMHpm)/(p1in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH2p)jgap+2.p1iMHpp)/(p1in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q2.m2()*qH2.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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: "<<p1out<<" "<<p1in<<" "<<p2out<<" "<<p2in<<" "<<pg<<std::endl;

	CLHEP::HepLorentzVector q1=p1in-p1out; // Top End
	CLHEP::HepLorentzVector q2=-(p2in-p2out); // Bottom End
	CLHEP::HepLorentzVector qg=p1in-p1out-pg; // Extra bit post-gluon

	// std::cerr<<"Current: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mj1m,mj1p,mj2m,mj2p,mjH2m,mjH2p;
	mj1p=jio(p1in,true,p1out,true);
	mj1m=jio(p1in,false,p1out,false);
	mjH2p=jioH(p2in,true,p2out,true,qH1,qH2, mt, incBot, mb);
	mjH2m=jioH(p2in,false,p2out,false,qH1,qH2, mt, incBot, mb);

	// Dot products of these which occur again and again
	COM MHmp=mj1m.dot(mjH2p); // And now for the Higgs ones
	COM MHmm=mj1m.dot(mjH2m);
	COM MHpp=mj1p.dot(mjH2p);
	COM MHpm=mj1p.dot(mjH2m);

	// Currents with pg
	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(MHmm) + (-2.mjH2m.dot(pg))mj1m+2.mj1m.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmm/2.))/q1.m2();
	Lmp=(qsum(MHmp) + (-2.mjH2p.dot(pg))mj1m+2.mj1m.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmp/2.))/q1.m2();
	Lpm=(qsum(MHpm) + (-2.mjH2m.dot(pg))mj1p+2.mj1p.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpm/2.))/q1.m2();
	Lpp=(qsum(MHpp) + (-2.mjH2p.dot(pg))mj1p+2.mj1p.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpp/2.))/q1.m2();

	U1mm=(jgam.dot(mjH2m)j2gm+2.p1o*MHmm)/(p1out+pg).m2();
	U1mp=(jgam.dot(mjH2p)j2gm+2.p1o*MHmp)/(p1out+pg).m2();
	U1pm=(jgap.dot(mjH2m)j2gp+2.p1o*MHpm)/(p1out+pg).m2();
	U1pp=(jgap.dot(mjH2p)j2gp+2.p1o*MHpp)/(p1out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH2m)jgam+2.p1iMHmm)/(p1in-pg).m2();
	U2mp=((-1.)j2gm.dot(mjH2p)jgam+2.p1iMHmp)/(p1in-pg).m2();
	U2pm=((-1.)j2gp.dot(mjH2m)jgap+2.p1iMHpm)/(p1in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH2p)jgap+2.p1iMHpp)/(p1in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q2.m2()*qH2.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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: "<<p1out<<" "<<p1in<<" "<<p2out<<" "<<p2in<<" "<<pg<<std::endl;

	CLHEP::HepLorentzVector q1=p1in-p1out; // Top End
	CLHEP::HepLorentzVector q2=-(p2in-p2out); // Bottom End
	CLHEP::HepLorentzVector qg=p1in-p1out-pg; // Extra bit post-gluon

	CCurrent mj1m,mj1p,mj2m,mj2p,mjH2m,mjH2p;
	mj1p=joi(p1out,true,p1in,true);
	mj1m=joi(p1out,false,p1in,false);
	mjH2p=jH(p2out,true,p2in,true,qH1,qH2, mt, incBot, mb);
	mjH2m=jH(p2out,false,p2in,false,qH1,qH2, mt, incBot, mb);

	// Dot products of these which occur again and again
	COM MHmp=mj1m.dot(mjH2p); // And now for the Higgs ones
	COM MHmm=mj1m.dot(mjH2m);
	COM MHpp=mj1p.dot(mjH2p);
	COM MHpm=mj1p.dot(mjH2m);

	// Currents with pg
	CCurrent jgam,jgap,j2gm,j2gp;
	j2gp=joo(p1out,true,pg,true);
	j2gm=joo(p1out,false,pg,false);
	jgap=joi(pg,true,p1in,true);
	jgam=joi(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(MHmm) + (-2.mjH2m.dot(pg))mj1m+2.mj1m.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmm/2.))/q1.m2();
	Lmp=(qsum(MHmp) + (-2.mjH2p.dot(pg))mj1m+2.mj1m.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmp/2.))/q1.m2();
	Lpm=(qsum(MHpm) + (-2.mjH2m.dot(pg))mj1p+2.mj1p.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpm/2.))/q1.m2();
	Lpp=(qsum(MHpp) + (-2.mjH2p.dot(pg))mj1p+2.mj1p.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpp/2.))/q1.m2();

	U1mm=(jgam.dot(mjH2m)j2gm+2.p1o*MHmm)/(p1out+pg).m2();
	U1mp=(jgam.dot(mjH2p)j2gm+2.p1o*MHmp)/(p1out+pg).m2();
	U1pm=(jgap.dot(mjH2m)j2gp+2.p1o*MHpm)/(p1out+pg).m2();
	U1pp=(jgap.dot(mjH2p)j2gp+2.p1o*MHpp)/(p1out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH2m)jgam+2.p1iMHmm)/(p1in-pg).m2();
	U2mp=((-1.)j2gm.dot(mjH2p)jgam+2.p1iMHmp)/(p1in-pg).m2();
	U2pm=((-1.)j2gp.dot(mjH2m)jgap+2.p1iMHpm)/(p1in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH2p)jgap+2.p1iMHpp)/(p1in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q2.m2()*qH2.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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

	const double K = K_g(p2out, p2in);

	return ampsqK/C_A9./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: "<<p1out<<" "<<p1in<<" "<<p2out<<" "<<p2in<<" "<<pg<<std::endl;

	CLHEP::HepLorentzVector q1=p1in-p1out; // Top End
	CLHEP::HepLorentzVector q2=-(p2in-p2out); // Bottom End
	CLHEP::HepLorentzVector qg=p1in-p1out-pg; // Extra bit post-gluon

	CCurrent mj1m,mj1p,mj2m,mj2p,mjH2m,mjH2p;
	mj1p=jio(p1in,true,p1out,true);
	mj1m=jio(p1in,false,p1out,false);
	mjH2p=jH(p2out,true,p2in,true,qH1,qH2, mt, incBot, mb);
	mjH2m=jH(p2out,false,p2in,false,qH1,qH2, mt, incBot, mb);

	// Dot products of these which occur again and again
	COM MHmp=mj1m.dot(mjH2p); // And now for the Higgs ones
	COM MHmm=mj1m.dot(mjH2m);
	COM MHpp=mj1p.dot(mjH2p);
	COM MHpm=mj1p.dot(mjH2m);

	// Currents with pg
	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(MHmm) + (-2.mjH2m.dot(pg))mj1m+2.mj1m.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmm/2.))/q1.m2();
	Lmp=(qsum(MHmp) + (-2.mjH2p.dot(pg))mj1m+2.mj1m.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHmp/2.))/q1.m2();
	Lpm=(qsum(MHpm) + (-2.mjH2m.dot(pg))mj1p+2.mj1p.dot(pg)mjH2m+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpm/2.))/q1.m2();
	Lpp=(qsum(MHpp) + (-2.mjH2p.dot(pg))mj1p+2.mj1p.dot(pg)mjH2p+(p2o/pg.dot(p2out) + p2i/pg.dot(p2in))(qg.m2()*MHpp/2.))/q1.m2();

	U1mm=(jgam.dot(mjH2m)j2gm+2.p1o*MHmm)/(p1out+pg).m2();
	U1mp=(jgam.dot(mjH2p)j2gm+2.p1o*MHmp)/(p1out+pg).m2();
	U1pm=(jgap.dot(mjH2m)j2gp+2.p1o*MHpm)/(p1out+pg).m2();
	U1pp=(jgap.dot(mjH2p)j2gp+2.p1o*MHpp)/(p1out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH2m)jgam+2.p1iMHmm)/(p1in-pg).m2();
	U2mp=((-1.)j2gm.dot(mjH2p)jgam+2.p1iMHmp)/(p1in-pg).m2();
	U2pm=((-1.)j2gp.dot(mjH2m)jgap+2.p1iMHpm)/(p1in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH2p)jgap+2.p1iMHpp)/(p1in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q2.m2()*qH2.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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

	const double K = K_g(p2out, p2in);

	return ampsq*K/C_F;
	}

	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 : "<<p1in<< " "<<p1in.plus()<<" "<<p1in.minus()<<std::endl;
	// std::cout << "# p2in : "<<p2in<< " "<<p2in.plus()<<" "<<p2in.minus()<<std::endl;
	// std::cout << "# p1out : "<<p1out<< " "<<p1out.rapidity()<<std::endl;
	// std::cout << "# (qH1-qH2) : "<<(qH1-qH2)<< " "<<(qH1-qH2).rapidity()<<std::endl;
	// std::cout << "# pg : "<<pg<< " "<<pg.rapidity()<<std::endl;
	// std::cout << "# p2out : "<<p2out<< " "<<p2out.rapidity()<<std::endl;
	// std::cout << "####################\n";

	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: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mjH1m,mjH1p,mj2m,mj2p;
	mjH1p=jHtop(p1out,true,p1in,true,qH1,qH2, mt, incBot, mb);
	mjH1m=jHtop(p1out,false,p1in,false,qH1,qH2, mt, incBot, mb);
	mj2p=joi(p2out,true,p2in,true);
	mj2m=joi(p2out,false,p2in,false);

	// Dot products of these which occur again and again
	COM MHmp=mjH1m.dot(mj2p); // And now for the Higgs ones
	COM MHmm=mjH1m.dot(mj2m);
	COM MHpp=mjH1p.dot(mj2p);
	COM MHpm=mjH1p.dot(mj2m);

	// Currents with pg
	CCurrent jgbm,jgbp,j2gm,j2gp;
	j2gp=joo(p2out,true,pg,true);
	j2gm=joo(p2out,false,pg,false);
	jgbp=joi(pg,true,p2in,true);
	jgbm=joi(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);

	CCurrent pplus((p1in+p1out)/2.);
	CCurrent pminus((p2in+p2out)/2.);

	// COM test=pminus.dot(p1in);

	Lmm=((-1.)qsum(MHmm) + (-2.mjH1m.dot(pg))mj2m+2.mj2m.dot(pg)mjH1m
	+ (p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmm/2.))/q3.m2();
	Lmp=((-1.)qsum(MHmp) + (-2.mjH1m.dot(pg))mj2p+2.mj2p.dot(pg)mjH1m
	+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmp/2.))/q3.m2();
	Lpm=((-1.)qsum(MHpm) + (-2.mjH1p.dot(pg))mj2m+2.mj2m.dot(pg)mjH1p
	+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpm/2.))/q3.m2();
	Lpp=((-1.)qsum(MHpp) + (-2.mjH1p.dot(pg))mj2p+2.mj2p.dot(pg)mjH1p
	+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpp/2.))/q3.m2();
	U1mm=(jgbm.dot(mjH1m)j2gm+2.p2o*MHmm)/(p2out+pg).m2();
	U1mp=(jgbp.dot(mjH1m)j2gp+2.p2o*MHmp)/(p2out+pg).m2();
	U1pm=(jgbm.dot(mjH1p)j2gm+2.p2o*MHpm)/(p2out+pg).m2();
	U1pp=(jgbp.dot(mjH1p)j2gp+2.p2o*MHpp)/(p2out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH1m)jgbm+2.p2iMHmm)/(p2in-pg).m2();
	U2mp=((-1.)j2gp.dot(mjH1m)jgbp+2.p2iMHmp)/(p2in-pg).m2();
	U2pm=((-1.)j2gm.dot(mjH1p)jgbm+2.p2iMHpm)/(p2in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH1p)jgbp+2.p2iMHpp)/(p2in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	// 1/3. = 1/C_A ?
	double ampsq=-(amm+amp+apm+app)/(q1.m2()*qH1.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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
	const double th=qH2.m2()*q2.m2();
	ampsq/=th;
	ampsq/=16.;
	ampsq=HEJ::C_FHEJ::C_F/(HEJ::C_A*HEJ::C_A); // 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: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mjH1m,mjH1p,mj2m,mj2p;
	mjH1p=jioHtop(p1in,true,p1out,true,qH1,qH2, mt, incBot, mb);
	mjH1m=jioHtop(p1in,false,p1out,false,qH1,qH2, mt, incBot, mb);
	mj2p=joi(p2out,true,p2in,true);
	mj2m=joi(p2out,false,p2in,false);

	// Dot products of these which occur again and again
	COM MHmp=mjH1m.dot(mj2p); // And now for the Higgs ones
	COM MHmm=mjH1m.dot(mj2m);
	COM MHpp=mjH1p.dot(mj2p);
	COM MHpm=mjH1p.dot(mj2m);


	// Currents with pg
	CCurrent jgbm,jgbp,j2gm,j2gp;
	j2gp=joo(p2out,true,pg,true);
	j2gm=joo(p2out,false,pg,false);
	jgbp=joi(pg,true,p2in,true);
	jgbm=joi(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);

	CCurrent pplus((p1in+p1out)/2.);
	CCurrent pminus((p2in+p2out)/2.);

	// COM test=pminus.dot(p1in);


	Lmm=((-1.)qsum(MHmm) + (-2.mjH1m.dot(pg))mj2m+2.mj2m.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmm/2.))/q3.m2();
	Lmp=((-1.)qsum(MHmp) + (-2.mjH1m.dot(pg))mj2p+2.mj2p.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmp/2.))/q3.m2();
	Lpm=((-1.)qsum(MHpm) + (-2.mjH1p.dot(pg))mj2m+2.mj2m.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpm/2.))/q3.m2();
	Lpp=((-1.)qsum(MHpp) + (-2.mjH1p.dot(pg))mj2p+2.mj2p.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpp/2.))/q3.m2();
	U1mm=(jgbm.dot(mjH1m)j2gm+2.p2o*MHmm)/(p2out+pg).m2();
	U1mp=(jgbp.dot(mjH1m)j2gp+2.p2o*MHmp)/(p2out+pg).m2();
	U1pm=(jgbm.dot(mjH1p)j2gm+2.p2o*MHpm)/(p2out+pg).m2();
	U1pp=(jgbp.dot(mjH1p)j2gp+2.p2o*MHpp)/(p2out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH1m)jgbm+2.p2iMHmm)/(p2in-pg).m2();
	U2mp=((-1.)j2gp.dot(mjH1m)jgbp+2.p2iMHmp)/(p2in-pg).m2();
	U2pm=((-1.)j2gm.dot(mjH1p)jgbm+2.p2iMHpm)/(p2in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH1p)jgbp+2.p2iMHpp)/(p2in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q1.m2()*qH1.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mjH1m,mjH1p,mj2m,mj2p;
	mjH1p=jHtop(p1out,true,p1in,true,qH1,qH2,mt, incBot, mb);
	mjH1m=jHtop(p1out,false,p1in,false,qH1,qH2,mt, incBot, mb);
	mj2p=jio(p2in,true,p2out,true);
	mj2m=jio(p2in,false,p2out,false);

	// Dot products of these which occur again and again
	COM MHmp=mjH1m.dot(mj2p); // And now for the Higgs ones
	COM MHmm=mjH1m.dot(mj2m);
	COM MHpp=mjH1p.dot(mj2p);
	COM MHpm=mjH1p.dot(mj2m);


	// Currents with pg
	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);

	CCurrent pplus((p1in+p1out)/2.);
	CCurrent pminus((p2in+p2out)/2.);

	// COM test=pminus.dot(p1in);


	Lmm=((-1.)qsum(MHmm) + (-2.mjH1m.dot(pg))mj2m+2.mj2m.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmm/2.))/q3.m2();
	Lmp=((-1.)qsum(MHmp) + (-2.mjH1m.dot(pg))mj2p+2.mj2p.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmp/2.))/q3.m2();
	Lpm=((-1.)qsum(MHpm) + (-2.mjH1p.dot(pg))mj2m+2.mj2m.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpm/2.))/q3.m2();
	Lpp=((-1.)qsum(MHpp) + (-2.mjH1p.dot(pg))mj2p+2.mj2p.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpp/2.))/q3.m2();
	U1mm=(jgbm.dot(mjH1m)j2gm+2.p2o*MHmm)/(p2out+pg).m2();
	U1mp=(jgbp.dot(mjH1m)j2gp+2.p2o*MHmp)/(p2out+pg).m2();
	U1pm=(jgbm.dot(mjH1p)j2gm+2.p2o*MHpm)/(p2out+pg).m2();
	U1pp=(jgbp.dot(mjH1p)j2gp+2.p2o*MHpp)/(p2out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH1m)jgbm+2.p2iMHmm)/(p2in-pg).m2();
	U2mp=((-1.)j2gp.dot(mjH1m)jgbp+2.p2iMHmp)/(p2in-pg).m2();
	U2pm=((-1.)j2gm.dot(mjH1p)jgbm+2.p2iMHpm)/(p2in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH1p)jgbp+2.p2iMHpp)/(p2in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q1.m2()*qH1.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mjH1m,mjH1p,mj2m,mj2p;
	mjH1p=jioHtop(p1in,true,p1out,true,qH1,qH2,mt, incBot, mb);
	mjH1m=jioHtop(p1in,false,p1out,false,qH1,qH2,mt, incBot, mb);
	mj2p=jio(p2in,true,p2out,true);
	mj2m=jio(p2in,false,p2out,false);

	// Dot products of these which occur again and again
	COM MHmp=mjH1m.dot(mj2p); // And now for the Higgs ones
	COM MHmm=mjH1m.dot(mj2m);
	COM MHpp=mjH1p.dot(mj2p);
	COM MHpm=mjH1p.dot(mj2m);


	// Currents with pg
	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);

	CCurrent pplus((p1in+p1out)/2.);
	CCurrent pminus((p2in+p2out)/2.);

	// COM test=pminus.dot(p1in);


	Lmm=((-1.)qsum(MHmm) + (-2.mjH1m.dot(pg))mj2m+2.mj2m.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmm/2.))/q3.m2();
	Lmp=((-1.)qsum(MHmp) + (-2.mjH1m.dot(pg))mj2p+2.mj2p.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmp/2.))/q3.m2();
	Lpm=((-1.)qsum(MHpm) + (-2.mjH1p.dot(pg))mj2m+2.mj2m.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpm/2.))/q3.m2();
	Lpp=((-1.)qsum(MHpp) + (-2.mjH1p.dot(pg))mj2p+2.mj2p.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpp/2.))/q3.m2();
	U1mm=(jgbm.dot(mjH1m)j2gm+2.p2o*MHmm)/(p2out+pg).m2();
	U1mp=(jgbp.dot(mjH1m)j2gp+2.p2o*MHmp)/(p2out+pg).m2();
	U1pm=(jgbm.dot(mjH1p)j2gm+2.p2o*MHpm)/(p2out+pg).m2();
	U1pp=(jgbp.dot(mjH1p)j2gp+2.p2o*MHpp)/(p2out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH1m)jgbm+2.p2iMHmm)/(p2in-pg).m2();
	U2mp=((-1.)j2gp.dot(mjH1m)jgbp+2.p2iMHmp)/(p2in-pg).m2();
	U2pm=((-1.)j2gm.dot(mjH1p)jgbm+2.p2iMHpm)/(p2in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH1p)jgbp+2.p2iMHpp)/(p2in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q1.m2()*qH1.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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 : "<<p1in<< " "<<p1in.plus()<<" "<<p1in.minus()<<std::endl;
	// std::cout << "# p2in : "<<p2in<< " "<<p2in.plus()<<" "<<p2in.minus()<<std::endl;
	// std::cout << "# p1out : "<<p1out<< " "<<p1out.rapidity()<<std::endl;
	// std::cout << "# (qH1-qH2) : "<<(qH1-qH2)<< " "<<(qH1-qH2).rapidity()<<std::endl;
	// std::cout << "# pg : "<<pg<< " "<<pg.rapidity()<<std::endl;
	// std::cout << "# p2out : "<<p2out<< " "<<p2out.rapidity()<<std::endl;
	// std::cout << "####################\n";

	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: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mjH1m,mjH1p,mj2m,mj2p;
	mjH1p=jHtop(p1out,true,p1in,true,qH1,qH2,mt, incBot, mb);
	mjH1m=jHtop(p1out,false,p1in,false,qH1,qH2,mt, incBot, mb);
	mj2p=joi(p2out,true,p2in,true);
	mj2m=joi(p2out,false,p2in,false);

	// Dot products of these which occur again and again
	COM MHmp=mjH1m.dot(mj2p); // And now for the Higgs ones
	COM MHmm=mjH1m.dot(mj2m);
	COM MHpp=mjH1p.dot(mj2p);
	COM MHpm=mjH1p.dot(mj2m);

	// Currents with pg
	CCurrent jgbm,jgbp,j2gm,j2gp;
	j2gp=joo(p2out,true,pg,true);
	j2gm=joo(p2out,false,pg,false);
	jgbp=joi(pg,true,p2in,true);
	jgbm=joi(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);

	CCurrent pplus((p1in+p1out)/2.);
	CCurrent pminus((p2in+p2out)/2.);

	// COM test=pminus.dot(p1in);

	Lmm=((-1.)qsum(MHmm) + (-2.mjH1m.dot(pg))mj2m+2.mj2m.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmm/2.))/q3.m2();
	Lmp=((-1.)qsum(MHmp) + (-2.mjH1m.dot(pg))mj2p+2.mj2p.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmp/2.))/q3.m2();
	Lpm=((-1.)qsum(MHpm) + (-2.mjH1p.dot(pg))mj2m+2.mj2m.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpm/2.))/q3.m2();
	Lpp=((-1.)qsum(MHpp) + (-2.mjH1p.dot(pg))mj2p+2.mj2p.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpp/2.))/q3.m2();
	U1mm=(jgbm.dot(mjH1m)j2gm+2.p2o*MHmm)/(p2out+pg).m2();
	U1mp=(jgbp.dot(mjH1m)j2gp+2.p2o*MHmp)/(p2out+pg).m2();
	U1pm=(jgbm.dot(mjH1p)j2gm+2.p2o*MHpm)/(p2out+pg).m2();
	U1pp=(jgbp.dot(mjH1p)j2gp+2.p2o*MHpp)/(p2out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH1m)jgbm+2.p2iMHmm)/(p2in-pg).m2();
	U2mp=((-1.)j2gp.dot(mjH1m)jgbp+2.p2iMHmp)/(p2in-pg).m2();
	U2pm=((-1.)j2gm.dot(mjH1p)jgbm+2.p2iMHpm)/(p2in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH1p)jgbp+2.p2iMHpp)/(p2in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q1.m2()*qH1.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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

	const double K = K_g(p1out, p1in);

	return ampsq*K/C_F;
	}



	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: "<<q1.m2()<<" "<<q2.m2()<<std::endl;
	CCurrent mjH1m,mjH1p,mj2m,mj2p;
	mjH1p=jHtop(p1out,true,p1in,true,qH1,qH2,mt, incBot, mb);
	mjH1m=jHtop(p1out,false,p1in,false,qH1,qH2,mt, incBot, mb);
	mj2p=jio(p2in,true,p2out,true);
	mj2m=jio(p2in,false,p2out,false);

	// Dot products of these which occur again and again
	COM MHmp=mjH1m.dot(mj2p); // And now for the Higgs ones
	COM MHmm=mjH1m.dot(mj2m);
	COM MHpp=mjH1p.dot(mj2p);
	COM MHpm=mjH1p.dot(mj2m);


	// Currents with pg
	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);

	CCurrent pplus((p1in+p1out)/2.);
	CCurrent pminus((p2in+p2out)/2.);

	// COM test=pminus.dot(p1in);


	Lmm=((-1.)qsum(MHmm) + (-2.mjH1m.dot(pg))mj2m+2.mj2m.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmm/2.))/q3.m2();
	Lmp=((-1.)qsum(MHmp) + (-2.mjH1m.dot(pg))mj2p+2.mj2p.dot(pg)mjH1m+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHmp/2.))/q3.m2();
	Lpm=((-1.)qsum(MHpm) + (-2.mjH1p.dot(pg))mj2m+2.mj2m.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpm/2.))/q3.m2();
	Lpp=((-1.)qsum(MHpp) + (-2.mjH1p.dot(pg))mj2p+2.mj2p.dot(pg)mjH1p+(p1o/pg.dot(p1out) + p1i/pg.dot(p1in))(q2.m2()MHpp/2.))/q3.m2();
	U1mm=(jgbm.dot(mjH1m)j2gm+2.p2o*MHmm)/(p2out+pg).m2();
	U1mp=(jgbp.dot(mjH1m)j2gp+2.p2o*MHmp)/(p2out+pg).m2();
	U1pm=(jgbm.dot(mjH1p)j2gm+2.p2o*MHpm)/(p2out+pg).m2();
	U1pp=(jgbp.dot(mjH1p)j2gp+2.p2o*MHpp)/(p2out+pg).m2();
	U2mm=((-1.)j2gm.dot(mjH1m)jgbm+2.p2iMHmm)/(p2in-pg).m2();
	U2mp=((-1.)j2gp.dot(mjH1m)jgbp+2.p2iMHmp)/(p2in-pg).m2();
	U2pm=((-1.)j2gm.dot(mjH1p)jgbm+2.p2iMHpm)/(p2in-pg).m2();
	U2pp=((-1.)j2gp.dot(mjH1p)jgbp+2.p2iMHpp)/(p2in-pg).m2();

	const double cf=HEJ::C_F;
	double amm,amp,apm,app;

	amm=cf(2.vre(Lmm-U1mm,Lmm+U2mm))+2.cfcf/3.*vabs2(U1mm+U2mm);
	amp=cf(2.vre(Lmp-U1mp,Lmp+U2mp))+2.cfcf/3.*vabs2(U1mp+U2mp);
	apm=cf(2.vre(Lpm-U1pm,Lpm+U2pm))+2.cfcf/3.*vabs2(U1pm+U2pm);
	app=cf(2.vre(Lpp-U1pp,Lpp+U2pp))+2.cfcf/3.*vabs2(U1pp+U2pp);
	double ampsq=-(amm+amp+apm+app)/(q1.m2()*qH1.m2());

	// if ((vabs2(Lmm-U1mm+U2mm)+vabs2(Lmm)-vabs2(U1mm)-vabs2(U2mm))/(2*vre(Lmm-U1mm,Lmm+U2mm)) > 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

	const double K = K_g(p1out, p1in);

	return ampsq*K/C_F; //ca/cf = 9/4

	}

	// Begin finite mass stuff
	#ifdef HEJ_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 = s12s34 - S1S2;
	Sigma = 4.s12s34 - pow(S1+S2,2);

	return looprwfactor(-s12D0DD(k2, k1, q2, mq)(1 - 8.mqmq/s12 + S2/(2.s12) +
	S2(s12 - 8.mqmq)(s34 + S1)/(2.s12Delta) +
	2.(s34 + S1)(s34 + S1)/Delta +
	S2pow((s34 + S1),3)/Delta/Delta) - ((s12 + S2)C0DD(k2,
	k1 + q2, mq) -
	s12C0DD(k1, k2, mq) + (S1 - S2)C0DD(k1 + k2, q2, mq) -
	S1*C0DD(k1, q2,
	mq))(S2(s12 - 4.mqmq)/(2.s12Delta) +
	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)/(DeltaSigma) +
	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))/(DeltaSigma));
	}
	//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 = s12s34 - S1S2;
	Sigma = 4.s12s34 - pow(S1+S2,2);

	return looprwfactor(-S2D0DD(k1, k2, q2,
	mq)(0.5 - (s12 - 8.mqmq)(s34 + S2)/(2.*Delta) -
	s12pow((s34 + S2),3)/Delta/Delta) + ((s12 + S1)C0DD(k1,
	k2 + q2, mq) -
	s12C0DD(k1, k2, mq) - (S1 - S2)C0DD(k1 + k2, q2, mq) -
	S2*C0DD(k2, q2,
	mq))(S2(s12 - 4.mqmq)/(2.s12Delta) +
	S2pow((s34 + S2),2)/Delta/Delta) - (C0DD(k1 + k2, q2, mq) - C0DD(k1, k2 + q2, mq))(1. - 4.mqmq/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) +
	s12C0DD(k1 + k2, q2, mq))2.s34(s34 +
	S2)(S2 - S1)/(DeltaSigma) + (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))/(DeltaSigma));
	}
	//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 = s12s34 - S1S2;

	return looprwfactor(S2D0DD(k1, q2, k2,
	mq)(Delta/s12/s12 - 4.mq*mq/s12) -
	S2((s12 + S1)C0DD(k1, k2 + q2, mq) -
	S1C0DD(k1, q2, mq))(1./
	s12/s12 - (s12 - 4.mqmq)/(2.s12Delta)) -
	S2((s12 + S2)C0DD(k1 + q2, k2, mq) -
	S2C0DD(k2, q2, mq))(1./
	s12/s12 + (s12 - 4.mqmq)/(2.s12Delta)) -
	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 = s12s34 - S1S2;
	Sigma = 4.s12s34 - pow(S1+S2,2);

	return looprwfactor* (-s12*D0DD(k2, k1, q2,
	mq)(0.5 - (S1 - 8.mqmq)(s34 + S1)/(2.*Delta) -
	s12pow((s34 + S1),3)/Delta/Delta) + ((s12 + S2)C0DD(k2,
	k1 + q2, mq) -
	s12C0DD(k1, k2, mq) + (S1 - S2)C0DD(k1 + k2, q2, mq) -
	S1C0DD(k1, q2, mq))((S1 - 4.mqmq)/(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.s12s34 - 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.s12s34 - S1*(S1 + S2) +
	s34(S2 - S1)))/(DeltaSigma)));
	}
	//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 = s12s34 - S1S2;
	Sigma = 4.s12s34 - pow(S1+S2,2);

	return looprwfactor* (-s12*D0DD(k1, k2, q2,
	mq)(0.5 + (S1 - 8.mqmq)(s34 + S2)/(2.*Delta) +
	s12pow((s34 + S2),3)/Delta/Delta) - ((s12 + S1)C0DD(k1,
	k2 + q2, mq) -
	s12C0DD(k1, k2, mq) - (S1 - S2)C0DD(k1 + k2, q2, mq) -
	S2C0DD(k2, q2, mq))((S1 - 4.mqmq)/(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) +
	s12C0DD(k1 + k2, q2, mq))2.s34(2.s12s34 -
	S1*(S1 + S2) +
	s12(S2 - S1))/(DeltaSigma) - (B0DD(k1 + k2, mq) -
	B0DD(k1 + k2 + q2, mq) - (s34 + S1 + S2)C0DD(k1 + k2, q2, mq))(2.s12(2.s12s34 - S2*(S1 + S2) +
	s34(S1 - S2))/(DeltaSigma)));
	}
	//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 = s12s34 - S1S2;

	return looprwfactor* (-D0DD(k1, q2, k2,
	mq)*(Delta/s12 + (s12 + S1)/2. -
	4.mqmq) + ((s12 + S1)*C0DD(k1, k2 + q2, mq) -
	S1C0DD(k1, q2, mq))(1./
	s12 - (S1 - 4.mqmq)/(2.Delta)) + ((s12 + S2)C0DD(
	k1 + q2, k2, mq) -
	S2C0DD(k2, q2, mq))(1./
	s12 + (S1 - 4.mqmq)/(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 = s12s34 - S1S2;
	Sigma = 4.s12s34 - pow(S1+S2,2);

	return looprwfactor(-s12D0DD(k2, k1, q2, mq)*((s34 + S1)/Delta +
	12.mqmqS1(s34 + S1)/Delta/Delta -
	4.s12S1pow((s34 + S1),3)/Delta/Delta/Delta) - ((s12 + S2)C0DD(k2, k1 + q2, mq) -
	s12C0DD(k1, k2, mq) + (S1 - S2)C0DD(k1 + k2, q2, mq) -
	S1C0DD(k1, q2, mq))(1./Delta +
	4.mqmq*S1/Delta/Delta -
	4.s12S1*pow((s34 + S1),2)/Delta/Delta/Delta) +
	C0DD(k1 + k2, q2, mq)(4.s12s34(S1 - S2)/(Delta*Sigma) -
	4.*(s12 -
	2.mqmq)(2.s12*s34 -
	S1(S1 + S2))/(DeltaSigma)) + (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) +
	s12C0DD(k1 + k2, q2, mq))(12.s34(2.*s12 + S1 +
	S2)(2.s12*s34 -
	S1(S1 + S2))/(DeltaSigma*Sigma) -
	4.s34(4.s12 + 3.S1 +
	S2)/(Delta*Sigma) +
	8.s12s34(s34(s12 + S2) -
	S1*(s34 +
	S1))/(DeltaDeltaSigma)) + (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))/(DeltaSigma*Sigma) +
	8.s12S1(s34(s12 + S2) -
	S1*(s34 +
	S1))/(DeltaDeltaSigma))) + (COM(0.,1.)/(4.M_PIM_PI))((2.s12*s34 -
	S1(S1 + S2))/(DeltaSigma));
	}

	//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 = s12s34 - S1S2;
	Sigma = 4.s12s34 - pow(S1+S2,2);

	return looprwfactor* (s12*D0DD(k1, k2, q2,
	mq)((s34 + S2)/Delta - 4.mq*mq/Delta +
	12.mqmqs34(s12 + S1)/Delta/Delta -
	4.s12pow((s34 + S2),2)/Delta/Delta -
	4.s12S1pow((s34 + S2),3)/Delta/Delta/Delta) + ((s12 + S1)C0DD(k1, k2 + q2, mq) -
	s12C0DD(k1, k2, mq) - (S1 - S2)C0DD(k1 + k2, q2, mq) -
	S2C0DD(k2, q2, mq))(1./Delta +
	4.mqmq*S1/Delta/Delta -
	4.s12(s34 + S2)/Delta/Delta -
	4.s12S1*pow((s34 + S2),2)/Delta/Delta/Delta) -
	C0DD(k1 + k2, q2, mq)(4.s12s34/(S2Delta) +
	4.s12s34(S2 - S1)/(DeltaSigma) +
	4.*(s12 -
	2.mqmq)(2.s12*s34 -
	S1(S1 + S2))/(DeltaSigma)) - (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))(-12s34(2s12 + S1 +
	S2)(2.s12*s34 -
	S1(S1 + S2))/(DeltaSigma*Sigma) -
	4.s12s34s34/(S2Delta*Delta) +
	4.s34S1/(Delta*Sigma) -
	4.s34(s12s34(2.*s12 + S2) -
	S1S1(2.*s12 +
	S1))/(DeltaDeltaSigma)) - (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))/(DeltaSigma*Sigma) +
	8.s12(2.s34 + S1)/(DeltaSigma) -
	8.s12s34(2.s12s34 - S1(S1 + S2) +
	s12*(S2 -
	S1))/(DeltaDeltaSigma))) + (COM(0.,1.)/(4.M_PIM_PI))((2.s12*s34 -
	S1(S1 + S2))/(DeltaSigma));

	}

	//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 = s12s34 - S1S2;

	return looprwfactor* (-D0DD(k1, q2, k2, mq)*(1. +
	4.S1mqmq/Delta) + ((s12 + S1)C0DD(k1,
	k2 + q2, mq) -
	S1C0DD(k1, q2, mq))(1./Delta +
	4.S1mqmq/Delta/Delta) - ((s12 + S2)C0DD(k1 + q2,
	k2, mq) - S2C0DD(k2, q2, mq))(1./Delta +
	4.S1mq*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.mqmq + 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;
	}
	/// @brief HC amp for qg->qgH with finite top (i.e. j^{++}_H)
	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;
	COM ang1a,sqa1;

	const double F = 4.mqmq/HEJ::vev;
	// 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){
	// sqrt(2pa_-/p1_-)*p1_perp/abs(p1_perp)
	ang1a = sqrt(pa.plus()p1.minus())(p1.x()+COM(0.,1.)*p1.y())/p1.perp();
	// sqrt(2pa_-/p1_-)p1_perp/abs(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());
	}


	const double prop = (pa-p1-pH).m2();

	cmult(-1./sqrt(2)/ang1a,cura1,conjeps1);
	cmult(1./sqrt(2)/sqa1,cura1,epsa);

	const COM Fta = FT(-pa,pa-pH,mq)/(pa-pH).m2();
	const COM Ft1 = FT(-p1-pH,p1,mq)/(p1+pH).m2();

	const COM h4 = H4(p1,-pa,pH,mq);
	const COM h5 = H5(p1,-pa,pH,mq);
	const COM h10 = H10(p1,-pa,pH,mq);
	const COM h12 = H12(p1,-pa,pH,mq);


	cmult(Fta*pa.dot(pH), epsa, epsHapart1);
	cmult(-1.Ftacdot(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);
	const COM aH1 = cdot(pHcur, cura1);

	current T1,T2,T3,T4,T5,T6,T7,T8,T9,T10;

	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.)Ftapa.dot(p1)*aH1/sqa1, conjeps1, T5);
	cmult(-sqrt(2.)Ft1pa.dot(p1)*aH1/ang1a, epsa, T6);

	cmult(-aH1/sqrt(2.)/sqa1h48.COM(0.,1.)M_PI*M_PI, conjeps1, T7);
	cmult(aH1/sqrt(2.)/ang1ah58.COM(0.,1.)M_PI*M_PI, epsa, T8);
	cmult(aH1aH1/2./ang1a/sqa1h108.COM(0.,1.)M_PIM_PI, pacur, T9);
	cmult(-aH1aH1/2./ang1a/sqa1h128.COM(0.,1.)M_PIM_PI, p1cur, T10);

	current ans;
	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];
	}

	/// @brief HNC amp for qg->qgH with finite top (i.e. j^{+-}_H)
	void g_gH_HNC(CLHEP::HepLorentzVector pa, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH, double mq, current &retAns)
	{
	const double F = 4.mqmq/HEJ::vev;
	COM ang1a,sqa1;
	current conjepsH1,epsHa,p1cur,pacur,pHcur,conjeps1,epsa,paplusp1cur,
	p1minuspacur,cur1a,cura1,epsHapart1,epsHapart2,conjepsH1part1,
	conjepsH1part2;
	// 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);
	joi(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);
	const COM aH1 = cdot(pHcur,cura1);
	const COM oneHa = std::conj(aH1); // = cdot(pHcur,cur1a)

	if(gluonforward){
	// sqrt(2pa_-/p1_-)*p1_perp/abs(p1_perp)
	ang1a = sqrt(pa.plus()p1.minus())(p1.x()+COM(0.,1.)*p1.y())/p1.perp();
	// sqrt(2pa_-/p1_-)p1_perp/abs(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());
	}

	const double prop = (pa-p1-pH).m2();

	cmult(1./sqrt(2)/sqa1, cur1a, epsa);
	cmult(-1./sqrt(2)/sqa1, cura1, conjeps1);
	const COM phase = cdot(conjeps1, epsa);
	const COM Fta = FT(-pa,pa-pH,mq)/(pa-pH).m2();
	const COM Ft1 = FT(-p1-pH,p1,mq)/(p1+pH).m2();
	const COM Falpha = FT(p1-pa,pa-p1-pH,mq);
	const COM Fbeta = FL(p1-pa,pa-p1-pH,mq);

	const COM h1 = H1(p1,-pa, pH, mq);
	const COM h2 = H2(p1,-pa, pH, mq);
	const COM h4 = H4(p1,-pa, pH, mq);
	const COM h5 = H5(p1,-pa, pH, mq);
	const COM h10 = H10(p1,-pa, pH, mq);
	const COM h12 = H12(p1,-pa, pH, mq);

	cmult(Fta*pa.dot(pH), epsa, epsHapart1);
	cmult(-1.Ftacdot(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);

	current T1,T2,T3,T4,T5a,T5b,T6,T7,T8a,T8b,T9,T10,T11a,
	T11b,T12a,T12b,T13;

	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);
	}

	const 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.phaseFta*pa.dot(pH), p1cur, T5a);
	cmult(2.phaseFt1*p1.dot(pH), pacur, T5b);
	cmult(-sqrt(2.)Ftap1.dot(pa)*oneHa/sqa1, conjeps1, T6);
	cmult(-sqrt(2.)Ft1pa.dot(p1)*aH1/sqa1, epsa, T7);

	cmult(-boxdiagFactphaseh2, pacur, T8a);
	cmult(boxdiagFactphaseh1, p1cur, T8b);
	cmult(boxdiagFactaH1/sqrt(2.)/sqa1h5, epsa, T9);
	cmult(-boxdiagFactoneHa/sqrt(2.)/sqa1h4, conjeps1, T10);
	cmult(boxdiagFactaH1oneHa/2./sqa1/sqa1*h10, pacur, T11a);
	cmult(-boxdiagFactaH1oneHa/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(-phaseFbeta(pa-p1-pH).m2(), paplusp1cur, T13);

	current ans;
	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;
	joi(p2out,true,p2in,true,cur2bplus);
	joi(p2out,false,p2in,false,cur2bminus);
	joi(ParityFlip(p2out),true,ParityFlip(p2in),true,cur2bplusFlip);
	joi(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);
	}
	#endif // HEJ_BUILD_WITH_QCDLOOP

	double C2gHgm(CLHEP::HepLorentzVector p2, CLHEP::HepLorentzVector p1, CLHEP::HepLorentzVector pH)
	{
	static double A=1./(3.M_PIHEJ::vev);
	// 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/p1pconj(p1perp)p3perp+p1p/p2pp1perp*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_PIHEJ::vev);
	// 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 or 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(p1perpp3perp)*pow(php/p1p,2)/(1.+php/p1p)
	+s12(pow(conj(phperp),2)/(pow(abs(phperp),2)+p1pphm)
	-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_PIHEJ::vev);
	// 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 or 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)p3perpconj(p1perp)
	+sqrt(p1p/p2p)p1perpconj(p3perp) );
	temp=temp*conj(temp);
	return temp.real();
	}
	diff --git a/src/kinematics.cc b/src/kinematics.cc
	index 785a460..456e0b4 100644
	--- a/src/kinematics.cc
	+++ b/src/kinematics.cc
	@@ -1,22 +1,23 @@
	#include "HEJ/kinematics.hh"

	#include "fastjet/PseudoJet.hh"

	-#include "HEJ/utility.hh"
	+// #include "HEJ/utility.hh"
	+#include "HEJ/Particle.hh"

	namespace HEJ{
	//reconstruct incoming momenta from momentum conservation
	std::tuple<fastjet::PseudoJet, fastjet::PseudoJet> incoming_momenta(
	std::vector<Particle> const & outgoing
	){
	double xa(0.), xb(0.);
	for(auto const & out: outgoing){
	xa += out.p.e() - out.p.pz();
	xb += out.p.e() + out.p.pz();
	}
	return std::tuple<fastjet::PseudoJet, fastjet::PseudoJet>{
	{0,0,-xa/2.,xa/2.},
	{0,0,xb/2.,xb/2.}
	};
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jan 20, 9:48 PM (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4231393
Default Alt Text: (289 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions