No OneTemporary
Actions

Size

71 KB

Subscribers

None

View Options

	diff --git a/DIPSY/DipoleEventHandler.cc b/DIPSY/DipoleEventHandler.cc
	--- a/DIPSY/DipoleEventHandler.cc
	+++ b/DIPSY/DipoleEventHandler.cc
	@@ -1,870 +1,882 @@
	// -- C++ --
	//
	// This is the implementation of the non-inlined, non-templated member
	// functions of the DipoleEventHandler class.
	//

	#include "DipoleEventHandler.h"
	#include "SimpleProtonState.h"
	#include "PhotonDipoleState.h"
	#include "Parton.h"
	#include "OldStyleEmitter.h"
	#include "ThePEG/Interface/Switch.h"
	#include "PT1DEmitter.h"
	#include "ThePEG/Repository/EventGenerator.h"
	#include "ThePEG/Repository/CurrentGenerator.h"
	#include "ThePEG/Repository/UseRandom.h"
	#include "ThePEG/Handlers/LuminosityFunction.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Interface/Parameter.h"
	#include "ThePEG/Interface/Reference.h"
	#include "ThePEG/Interface/RefVector.h"
	#include "ThePEG/Config/algorithm.h"
	#include "gsl/gsl_sf_bessel.h"
	#include "ThePEG/Utilities/Current.h"
	#include "ThePEG/Cuts/Cuts.h"
	#include "ThePEG/PDF/PartonExtractor.h"
	#include "ThePEG/Utilities/Debug.h"
	#include "ThePEG/Utilities/DebugItem.h"

	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"
	#include "CPUTimer.h"

	#include <iostream>
	#include <fstream>

	using namespace DIPSY;

	DipoleEventHandler::DipoleEventHandler()
	- : EventHandler(false), theNColours(9), theRMax(3.5*InvGeV),
	+ : EventHandler(false), theNColours(9), theRMax(3.5*InvGeV), thePTScale(2.0),
	theBaryonSize(0.0*InvGeV),
	theCoherenceRange(0.5*InvGeV), theEffectivePartonMode(0), theCollisionType(0),
	doShowHistory(false), theLambdaQCD(0.22*GeV), theNF(0),
	theFixedAlphaS(0.0), theExternalAlphaS(ASPtr()),
	theWFR(WaveFunctionPtr()), theWFL(WaveFunctionPtr()),
	theBGen(ImpactParameterGeneratorPtr()), theYFrame(0.5), theFudgeME(0), theFudgeFactorME(1.0),
	thePreSamples(1000), thePreSampleL(1), thePreSampleR(1), thePreSampleB(1),
	theXSecFn(DipoleXSecPtr()), theEmitter(EmitterPtr()),
	theSwinger(SwingerPtr()) {}

	DipoleEventHandler::~DipoleEventHandler() {}

	IBPtr DipoleEventHandler::clone() const {
	return new_ptr(*this);
	}

	IBPtr DipoleEventHandler::fullclone() const {
	return new_ptr(*this);
	}

	double DipoleEventHandler::elapsed() {
	static long last = 0;
	long el = clock() - last;
	last += el;
	return double(el)*0.000001;
	}

	void DipoleEventHandler::presample() {
	//redirect diffractive runs, as the cross section calculation
	//then requires more than a single loop over collisions.
	if ( collisionType() == 1 ) return diffractivePresample();

	//Set up before the loop
	Current<DipoleEventHandler> current(this);
	for_each(analyses, mem_fun(&DipoleAnalysisHandler::initialize));
	CrossSection xmax = 0.0*picobarn;
	CrossSection xnmax = 0.0*picobarn;
	elapsed();
	generator()->log()
	<< endl << "Starting DIPSY run at CoM energy "
	<< lumiFn().maximumCMEnergy()/GeV << " GeV" << endl;

	//Loop over collisions
	for ( int i = 0, N = preSamples(); i < N; ++i ) {
	//Setup before collision. Energy, jacobian, luminosity.
	Energy W = lumiFn().maximumCMEnergy();
	double jac = 1.0;
	pair<double,double> ll(1.0, 1.0);
	if ( int ndim = lumiFn().nDim(make_pair(WFL().particle(), WFR().particle())) ) {
	vector<double> r = UseRandom::rndvec(ndim);
	ll = lumiFn().generateLL(&(r[0]), jac);
	W = exp(-0.5(ll.first + ll.second));
	}

	//Find the p+ (or p-) of each state.
	Energy2 a = WFL().m2() - WFR().m2() + sqr(W);
	Energy PL = (a + sqrt(sqr(a) - WFL().m2()sqr(W)))0.5/W;
	a = WFR().m2() - WFL().m2() + sqr(W);
	Energy PR = (a + sqrt(sqr(a) - WFR().m2()sqr(W)))0.5/W;

	//Create the dipole states and impact parameters.
	vector<DipoleStatePtr> vl(preSampleL());
	vector<DipoleStatePtr> vr(preSampleR());
	vector<ImpactParameters> vb(preSampleB());
	vector< vector< vector<double> > >
	probs(preSampleL(),
	vector< vector<double> >(preSampleR(), vector<double>(preSampleB(), 0.0)));

	// Setup a number of left- and right-moving states
	double highYL = 0.0;
	for ( int il = 0; il < preSampleL(); ++il ) {
	DipoleStatePtr dl = WFL().generate(*this, PL);
	vl[il] = dl;
	dl->collidingEnergy(PR);
	highYL += dl->highestY();
	}
	double highYR = 0.0;
	for ( int ir = 0; ir < preSampleR(); ++ir ) {
	DipoleStatePtr dr = WFR().generate(*this, PR);
	vr[ir] = dr;
	dr->collidingEnergy(PL);
	highYR += dr->highestY();
	}

	// Evolve the states
	double y0 = interactionFrame(highYL/double(preSampleL()), -highYR/double(preSampleR()));
	for ( int il = 0; il < preSampleL(); ++il ) {
	vl[il]->evolve(vl[il]->lowestY(), y0);
	vl[il]->unifyColourSystems();
	}
	for ( int ir = 0; ir < preSampleR(); ++ir ) {
	vr[ir]->evolve(vr[ir]->lowestY(), -y0);
	vr[ir]->unifyColourSystems();
	}

	for ( int ib = 0; ib < preSampleB(); ++ib ) {
	ImpactParameters b = bGen().generate();
	vb[ib] = b;
	}

	for ( int il = 0; il < preSampleL(); ++il )
	for ( int ir = 0; ir < preSampleR(); ++ir )
	for ( int ib = 0; ib < preSampleB(); ++ib ) {
	DipoleStatePtr dl =vl[il];
	DipoleStatePtr dr =vr[ir];
	ImpactParameters b = vb[ib];
	double prob = 0;
	//Calculate interaction probability, and apply all the weights
	if ( eventFiller().mode() == 4 \|\| effectivePartonMode() < 0 )
	prob = xSecFn().sumf(b, dr, dl);
	else
	prob = xSecFn().sumf(dr, dl, b);

	probs[il][ir][ib] = prob;
	CrossSection weight = sqr(hbarc)dr->weight()dl->weight()b.weight()jac;
	//This is the contribution to the non-diffractive
	//cross section 1 - exp(-2(amp)^2)
	CrossSection x = weightxSecFn().unitarize(2.0prob);
	if ( x > xmax ) {
	xnmax = xmax;
	xmax = x;
	} else
	xnmax = max(x, xnmax);

	//Call the analysis (which calculates cross sections)
	for ( int i = 0, N = analyses.size(); i < N; ++i )
	analyses[i]->analyze(dr, dl, b, xSecFn(), prob, weight);
	}
	// Call the analysis (which calculates cross sections) for all
	// systems and impact parameters.
	for ( int i = 0, N = analyses.size(); i < N; ++i )
	analyses[i]->analyze(vr, vl, vb, xSecFn(), probs, jac);
	}

	//Write output (also from the called analyses) to log file.
	if ( preSamples() > 0 ) {
	generator()->log()
	<< "Presampled " << preSamples() << " collisions ("
	<< elapsed()/max(preSamples(),0) << " seconds per collisions)" << endl
	<< "Maximum cross section: "
	<< ouniterr(xmax, xmax-xnmax, nanobarn) << " nb." <<endl;
	for_each(analyses,
	bind2nd(mem_fun(&DipoleAnalysisHandler::finalize),
	preSamples()preSampleL()preSampleR()*preSampleB()));
	generator()->log() << endl;
	}
	stats = XSecStat(xmax > 0.0nanobarn? xmax: 1.0millibarn);
	}

	void DipoleEventHandler::diffractivePresample() {

	//Setup before
	Current<DipoleEventHandler> current(this);
	for_each(analyses, mem_fun(&DipoleAnalysisHandler::initialize));
	CrossSection xmax = 0.0*picobarn;
	CrossSection xnmax = 0.0*picobarn;
	elapsed();
	generator()->log()
	<< endl << "Starting Diffractive DIPSY run at CoM energy "
	<< lumiFn().maximumCMEnergy()/GeV << " GeV" << endl;
	Energy W = lumiFn().maximumCMEnergy();
	double jac = 1.0;
	pair<double,double> ll(1.0, 1.0);

	//Create the starting states from their wavefunction.
	if ( int ndim = lumiFn().nDim(make_pair(WFL().particle(), WFR().particle())) ) {
	vector<double> r = UseRandom::rndvec(ndim);
	ll = lumiFn().generateLL(&(r[0]), jac);
	W = exp(-0.5(ll.first + ll.second));
	}

	//Calculate the energy of each incoming state in this frame.
	Energy2 a = WFL().m2() - WFR().m2() + sqr(W);
	Energy PL = (a + sqrt(sqr(a) - WFL().m2()sqr(W)))0.5/W;
	a = WFR().m2() - WFL().m2() + sqr(W);
	Energy PR = (a + sqrt(sqr(a) - WFR().m2()sqr(W)))0.5/W;

	//Set up rapidity intervals to evolve over.
	double y0 = interactionFrame(-log(PL/sqrt(abs(WFL().m2()))), log(PR/sqrt(abs(WFR().m2()))));

	//Pre-generate the virtual cascade, ie the ones from the
	//elastic side (right side by default).
	vector<DipoleStatePtr> virtualCascades;
	for ( int i = 0, N = preSamples(); i < N; i ++ ) {
	DipoleStatePtr virt = WFR().generate(*this, PR);
	virt->collidingEnergy(PL);
	virt->evolve(virt->lowestY(), -y0);
	virtualCascades.push_back(virt);
	}

	CrossSection sigmaSD = ZERO;
	QTY<4,0,0>::Type sigmaSD2 = ZERO;

	//Now run main loop over the real (excited in final state) cascades.
	for ( int i = 0, N = preSamples(); i < N; ++i ) {

	DipoleStatePtr dl = WFL().generate(*this, PL);
	dl->collidingEnergy(PR);
	dl->evolve(dl->lowestY(), y0);
	ImpactParameters b = bGen().generate();

	double sum = 0.0;
	double sumWeights = 0.0;

	//Loop over the pregenerated virtual elastic
	for ( int j = 0; j < N; j ++ ) {
	double amp = xSecFn().unitarize(xSecFn().sumf(virtualCascades[j], dl, b));
	sum += amp*virtualCascades[j]->weight();
	sumWeights += virtualCascades[j]->weight();
	}
	double average = sum/sumWeights;

	//Take statistics on inclusive single diffractive cross section.
	CrossSection weight = sqr(hbarc)dl->weight()b.weight()*jac;
	CrossSection x = weight*average;
	sigmaSD += weight*sqr(average);
	sigmaSD2 += sqr(weight*sqr(average));
	if ( x > xmax ) {
	xnmax = xmax;
	xmax = x;
	} else
	xnmax = max(x, xnmax);
	//Pass on to analysers.
	for ( int j = 0, M = analyses.size(); j < M; ++j )
	analyses[j]->analyze(WFR().generate(this, PR), *dl, b, xSecFn(), average, weight);
	}

	//Output results to log file.
	if ( preSamples() > 0 ) {
	sigmaSD /= preSamples();
	sigmaSD2 /= preSamples();
	//Estimate error from the fluctuations.
	CrossSection err = sqrt((sigmaSD2 - sqr(sigmaSD))/preSamples());
	generator()->log()
	<< "Presampled " << preSamples() << " real cascades, collided with "
	<< preSamples() << " virtual cascades ("
	<< elapsed()/max(preSamples(),0) << " seconds per real cascade)" << endl
	<< "Maximum cross section: "
	<< ouniterr(xmax, xmax-xnmax, nanobarn) << " nb." <<endl
	<< "Integrated single diffractive cross section up to y = " << y0
	<< " is " << ouniterr(sigmaSD, err, nanobarn) << " nb." <<endl;
	for_each(analyses,
	bind2nd(mem_fun(&DipoleAnalysisHandler::finalize), preSamples()));
	generator()->log() << endl;
	}
	stats = XSecStat(xmax > 0.0nanobarn? xmax: 1.0millibarn);
	}


	void DipoleEventHandler::initialize() {
	Current<DipoleEventHandler> current(this);
	theWFL->initialize(*this);
	theWFR->initialize(*this);
	}

	EventPtr DipoleEventHandler::generateEvent() {
	//Redirect diffractive events.
	if ( collisionType() == 1 ) return generateDiffractiveEvent();

	while ( true ) {
	Current<DipoleEventHandler> current(this);

	//Set up energy, jacobians and wavefunctions.
	Energy W = lumiFn().maximumCMEnergy();
	double jac = 1.0;
	pair<double,double> ll(1.0, 1.0);
	if ( int ndim = lumiFn().nDim(make_pair(WFL().particle(), WFR().particle())) ) {
	vector<double> r = UseRandom::rndvec(ndim);
	ll = lumiFn().generateLL(&(r[0]), jac);
	}

	//Find lightcone momenta.
	Energy2 a = WFL().m2() - WFR().m2() + sqr(W);
	Energy PL = (a + sqrt(sqr(a) - 4.0WFL().m2()sqr(W)))*0.5/W;
	a = WFR().m2() - WFL().m2() + sqr(W);
	Energy PR = (a + sqrt(sqr(a) - 4.0WFR().m2()sqr(W)))*0.5/W;

	PPair inc(WFL().particle()->produceParticle(lightCone(PL, WFL().m2()/PL)),
	WFR().particle()->produceParticle(lightCone(WFR().m2()/PR, PR)));
	LorentzRotation cmboost =
	lumiFn().getBoost()LorentzRotation(0.0, 0.0, tanh(0.5(ll.second - ll.first)));
	inc.first->transform(cmboost);
	inc.second->transform(cmboost);

	//Create dipole states.
	DipoleStatePtr dr = WFR().generate(*this, PR);
	DipoleStatePtr dl = WFL().generate(*this, PL);

	//in some settings, the states need to know about the
	//energy of the other state.
	dr->collidingEnergy(PL);
	dl->collidingEnergy(PR);

	double y0 = interactionFrame(dl->highestY(), -dr->highestY());

	dr->evolve(dr->lowestY(), -y0);
	dr->unifyColourSystems();
	dl->evolve(dl->lowestY(), y0);
	dl->unifyColourSystems();

	// This generates the impact parameter depending on the position
	//of the partons. Intention was to generate high-pt events more
	//often by selecting a b such that two partons would end up
	//very close to each other more often. Should work in theory, but
	//didn't make as big difference as hoped, maybe due to too many
	//of the high pTs coming from the cascade.
	// vector<pair<Parton::Point, InvEnergy> > points1 = dl->points();
	// vector<pair<Parton::Point, InvEnergy> > points2 = dr->points();
	// ImpactParameters b = bGen().generateDynamic(points1, points2);

	//Standard impact parameter generation.
	ImpactParameters b = bGen().generate();
	inc.first->setVertex
	(LorentzPoint(hbarcb.bVec().x()/2, hbarcb.bVec().y()/2, ZERO, ZERO));
	inc.second->setVertex
	(LorentzPoint(-hbarcb.bVec().x()/2, -hbarcb.bVec().y()/2, ZERO, ZERO));

	currentEvent(new_ptr(Event(inc, this, generator()->runName(),
	generator()->currentEventNumber(), 1.0)));
	currentCollision(new_ptr(Collision(inc, currentEvent(), this)));
	if ( currentEvent() ) currentEvent()->addCollision(currentCollision());
	currentStep(new_ptr(Step(currentCollision())));
	currentCollision()->addStep(currentStep());

	double genweight = sqr(hbarc)dr->weight()dl->weight()b.weight()jac/
	stats.maxXSec();

	//Pass to filler. This is where the final state is decided.
	double prob = eventFiller().fill(currentStep(), this, inc, dl, dr, b);

	double weight = prob*genweight;
	stats.select(weight);
	currentEvent()->weight(weight);
	if ( weight <= 0.0 ) continue;
	stats.accept();

	try {
	initGroups();
	continueCollision();
	return currentEvent();
	}
	catch (Veto) {
	stats.reject(weight);
	}
	catch (Stop) {
	break;
	}
	catch (Exception &) {
	stats.reject(weight);
	throw;
	}
	}
	return currentEvent();
	}

	EventPtr DipoleEventHandler::generateDiffractiveEvent() {

	//Very similar to generateEvent.
	while ( true ) {
	//Same setup as in the non-diffractive case.
	Current<DipoleEventHandler> current(this);
	Energy W = lumiFn().maximumCMEnergy();
	double jac = 1.0;
	pair<double,double> ll(1.0, 1.0);
	if ( int ndim = lumiFn().nDim(make_pair(WFL().particle(), WFR().particle())) ) {
	vector<double> r = UseRandom::rndvec(ndim);
	ll = lumiFn().generateLL(&(r[0]), jac);
	}
	Energy2 a = WFL().m2() - WFR().m2() + sqr(W);
	Energy PL = (a + sqrt(sqr(a) - 4.0WFL().m2()sqr(W)))*0.5/W;
	a = WFR().m2() - WFL().m2() + sqr(W);
	Energy PR = (a + sqrt(sqr(a) - 4.0WFR().m2()sqr(W)))*0.5/W;
	PPair inc(WFL().particle()->produceParticle(lightCone(PL, WFL().m2()/PL)),
	WFR().particle()->produceParticle(lightCone(WFL().m2()/PR, PR)));
	LorentzRotation cmboost =
	lumiFn().getBoost()LorentzRotation(0.0, 0.0, tanh(0.5(ll.second - ll.first)));
	inc.first->transform(cmboost);
	inc.second->transform(cmboost);

	//create real excited valence. Evolution is done in diffFill.
	DipoleStatePtr dr = WFL().generate(*this, PL);
	//create elastic
	DipoleStatePtr de = WFR().generate(*this, PR);

	ImpactParameters b = bGen().generate();

	inc.first->setVertex
	(LorentzPoint(hbarcb.bVec().x()/2, hbarcb.bVec().y()/2, ZERO, ZERO));
	inc.second->setVertex
	(LorentzPoint(-hbarcb.bVec().x()/2, -hbarcb.bVec().y()/2, ZERO, ZERO));

	currentEvent(new_ptr(Event(inc, this, generator()->runName(),
	generator()->currentEventNumber(), 1.0)));
	currentCollision(new_ptr(Collision(inc, currentEvent(), this)));
	if ( currentEvent() ) currentEvent()->addCollision(currentCollision());
	currentStep(new_ptr(Step(currentCollision())));
	currentCollision()->addStep(currentStep());

	double genweight = sqr(hbarc)dr->weight()de->weight()b.weight()jac/
	stats.maxXSec();

	//Call filler, which will be redirected to diffractive version.
	double prob = eventFiller().fill(currentStep(), this, inc, dr, de, b);
	double weight = prob*genweight;

	if ( weight <= 0.0 ) continue;
	if ( isnan(weight) ) {
	continue;
	}

	stats.select(weight);
	currentEvent()->weight(weight);
	stats.accept();

	try {
	initGroups();
	continueCollision();
	return currentEvent();
	}
	catch (Veto) {
	stats.reject(weight);
	}
	catch (Stop) {
	break;
	}
	catch (Exception &) {
	stats.reject(weight);
	throw;
	}
	}
	return currentEvent();
	}

	CrossSection DipoleEventHandler::integratedXSec() const {
	return stats.xSec();
	}

	CrossSection DipoleEventHandler::integratedXSecErr() const {
	return stats.xSecErr();
	}

	CrossSection DipoleEventHandler::maxXSec() const {
	return stats.maxXSec();
	}

	CrossSection DipoleEventHandler::histogramScale() const {
	return stats.xSec()/stats.sumWeights();
	}

	void DipoleEventHandler::statistics(ostream & os) const {
	string line = "======================================="
	"=======================================\n";

	if ( stats.accepted() <= 0 ) {
	os << line << "No events generated by event handler '" << name() << "'."
	<< endl;
	return;
	}

	os << line << "Statistics for event handler \'" << name() << "\':\n"
	<< " "
	<< "generated number of Cross-section\n"
	<< " "
	<< " events attempts (nb)\n";

	os << line << "Total:" << setw(42) << stats.accepted() << setw(13)
	<< stats.attempts() << setw(17)
	<< ouniterr(stats.xSec(), stats.xSecErr(), nanobarn)
	<< endl << line;


	}

	void DipoleEventHandler::doinit() throw(InitException) {

	Current<DipoleEventHandler> current(this);

	EventHandler::doinit();
	}

	void DipoleEventHandler::dofinish() {
	generator()->log() << endl << "Ending DIPSY run at CoM energy "
	<< lumiFn().maximumCMEnergy()/GeV << " GeV" << endl;
	theEventFiller->finish();
	EventHandler::dofinish();
	CPUClock::dump(generator()->log());
	}

	void DipoleEventHandler::doinitrun() {
	Current<DipoleEventHandler> current(this);

	EventHandler::doinitrun();
	theNErr = 0;
	for_each(analyses, mem_fun(&DipoleAnalysisHandler::initrun));
	if ( theSwinger ) theSwinger->initrun();
	theEmitter->initrun();
	theBGen->initrun();
	theXSecFn->initrun();
	theEventFiller->initrun();
	theWFL->initrun();
	theWFR->initrun();
	if ( externalAlphaS() ) externalAlphaS()->initrun();
	presample();

	// Fix up a dummy XComb object
	Energy emax = lumiFn().maximumCMEnergy();
	cuts()->initialize(sqr(emax), 0.0);
	cPDPair incoming = make_pair(WFL().particle(), WFR().particle());
	PartonPairVec bins = partonExtractor()->getPartons(emax, incoming, *cuts());
	theLastXComb = new_ptr(XComb(emax, incoming, this, partonExtractor(),
	tCascHdlPtr(), bins[0], cuts()));
	theLastXComb->lastSHat(sqr(emax));
	theLastXComb->lastY(0.0);
	theLastXComb->lastP1P2(make_pair(0.0, 0.0));
	theLastXComb->lastL1L2(make_pair(0.0, 0.0));
	theLastXComb->lastX1X2(make_pair(1.0, 1.0));
	theLastXComb->lastScale(sqr(emax));
	theLastXComb->lastAlphaS(1.0);
	theLastXComb->lastAlphaEM(1.0/137.0);
	partonExtractor()->select(theLastXComb);
	}

	void DipoleEventHandler::rebind(const TranslationMap & trans) throw(RebindException) {
	// dummy = trans.translate(dummy);
	EventHandler::rebind(trans);
	}

	IVector DipoleEventHandler::getReferences() {
	IVector ret = EventHandler::getReferences();
	// ret.push_back(dummy);
	return ret;
	}


	double DipoleEventHandler::alphaS(InvEnergy r) const {
	if ( fixedAlphaS() > 0.0 )
	return fixedAlphaS();
	- else if ( LambdaQCD() > 0.0*GeV && LambdaQCD() < 2.0/rMax() )
	+ else if ( LambdaQCD() > 0.0*GeV && LambdaQCD() < pTScale()/rMax() )
	return 6.0Constants::pi/((33.0 - 2.0nF())*
	- log(2.0/(min(r,rMax())*LambdaQCD())));
	+ log(pTScale()/(min(r,rMax())*LambdaQCD())));
	else if ( externalAlphaS() )
	- return externalAlphaS()->value(sqr(2.0/min(r,rMax())), SM());
	+ return externalAlphaS()->value(sqr(pTScale()/min(r,rMax())), SM());
	else
	- return SM().alphaS(sqr(2.0/min(r,rMax())));
	+ return SM().alphaS(sqr(pTScale()/min(r,rMax())));
	}

	double DipoleEventHandler::interactionFrame(double ymin, double ymax) const {
	double yframe = yFrame();
	if ( yFrame() < -1.0 && yFrame() >= -1.5 ) {
	double dum = -(yFrame() + 1.0);
	yframe = UseRandom::rnd(dum, 1.0 - dum);
	}
	double y0 = ymin + yframe*(ymax - ymin);
	if ( y0 > ymax ) y0 = max(ymin, ymax + (1.0 - yframe));
	else if ( y0 < ymin ) y0 = min(ymax, ymin + yframe);
	return y0;
	}

	void DipoleEventHandler::persistentOutput(PersistentOStream & os) const {
	- os << theNColours << ounit(theRMax, InvGeV) << ounit(theBaryonSize, InvGeV)
	+ os << theNColours << ounit(theRMax, InvGeV) << thePTScale
	+ << ounit(theBaryonSize, InvGeV)
	<< ounit(theCoherenceRange, InvGeV)
	<< theEffectivePartonMode << theCollisionType << doShowHistory
	<< ounit(theLambdaQCD, GeV) << theNF << theFixedAlphaS << theExternalAlphaS
	<< theWFR << theWFL << theBGen << theYFrame << theFudgeME << theFudgeFactorME << thePreSamples << thePreSampleL
	<< thePreSampleR << thePreSampleB << theXSecFn << theEmitter << theSwinger
	<< theEventFiller << analyses << stats;
	}

	void DipoleEventHandler::persistentInput(PersistentIStream & is, int) {
	- is >> theNColours >> iunit(theRMax, InvGeV) >> iunit(theBaryonSize, InvGeV)
	+ is >> theNColours >> iunit(theRMax, InvGeV) >> thePTScale
	+ >> iunit(theBaryonSize, InvGeV)
	>> iunit(theCoherenceRange, InvGeV)
	>> theEffectivePartonMode >> theCollisionType >> doShowHistory
	>> iunit(theLambdaQCD, GeV) >> theNF >> theFixedAlphaS >> theExternalAlphaS
	>> theWFR >> theWFL >> theBGen >> theYFrame >> theFudgeME >> theFudgeFactorME >> thePreSamples >> thePreSampleL
	>> thePreSampleR >> thePreSampleB >> theXSecFn >> theEmitter >> theSwinger
	>> theEventFiller >> analyses >> stats;
	}


	// Static variable needed for the type description system in ThePEG.
	#include "ThePEG/Utilities/DescribeClass.h"
	DescribeClass<DipoleEventHandler,EventHandler>
	describeDIPSYDipoleEventHandler("DIPSY::DipoleEventHandler",
	"libAriadne5.so libDIPSY.so");


	void DipoleEventHandler::Init() {

	static ClassDocumentation<DipoleEventHandler> documentation
	("The DipoleEventHandler is a special EventHandler capable of generating "
	"minimum-bias events using the Lund version of the Mueller dipole model.");

	static Parameter<DipoleEventHandler,int> interfaceNColours
	("NColours",
	"The number of different colour indices in the swing mechanism. Should be "
	"\\f$N_c^2\\f$ but can be varied to investigate swing effects.",
	&DipoleEventHandler::theNColours, 9, 3, 0,
	true, false, Interface::lowerlim);

	static Parameter<DipoleEventHandler,InvEnergy> interfaceRMax
	("RMax",
	"The general hadronic size in units of inverse GeV.",
	&DipoleEventHandler::theRMax, InvGeV, 3.5InvGeV, 0.0InvGeV, 0*InvGeV,
	true, false, Interface::lowerlim);

	+
	+ static Parameter<DipoleEventHandler,double> interfacePTScale
	+ ("PTScale",
	+ "The scale used to relate impactparameter distances and transverse "
	+ "momenta. If negative, it is instead taken from the assigned "
	+ "<interface>Emitter::PTScale</interface>.",
	+ &DipoleEventHandler::thePTScale, 2.0, 0, 0,
	+ true, false, Interface::nolimits);
	+
	+
	static Parameter<DipoleEventHandler,InvEnergy> interfaceCoherenceRange
	("CoherenceRange",
	"The maximum range at which partons are allowed to emit coherently."
	"This is also used as maximum range in the DGLAP suppression",
	&DipoleEventHandler::theCoherenceRange, InvGeV, 0.5InvGeV, 0.0InvGeV, 0*InvGeV,
	true, false, Interface::lowerlim);

	static Switch<DipoleEventHandler,int> interfaceEffectivePartonMode
	("EffectivePartonMode",
	"How the partons are grouped inteo effective partons.",
	&DipoleEventHandler::theEffectivePartonMode, 0, true, false);
	static SwitchOption interfaceEffectivePartonModeColours
	(interfaceEffectivePartonMode,
	"Colours",
	"Groups with colour neighbours. Makes more sence since the "
	"colour flow determines how the emissions are made, but the "
	"swing makes this mode not always group up recoiling partons, "
	"which can mess up availible phase space and ordering. "
	"This is default.",
	0);
	static SwitchOption interfaceEffectivePartonModeFastColours
	(interfaceEffectivePartonMode,
	"FastColours",
	"Groups with colour neighbours as for the \"Colour\" option, "
	"but speed up the generation by caching different ranges for "
	"the same parton.",
	2);
	static SwitchOption interfaceEffectivePartonModeFastColours2
	(interfaceEffectivePartonMode,
	"FastColours2",
	"Groups with colour neighbours as for the \"FastColour\" option, "
	"but speed up the generation by caching different ranges for "
	"the same parton.",
	3);
	static SwitchOption interfaceEffectivePartonModeRelatives
	(interfaceEffectivePartonMode,
	"Relatives",
	"Groups with parents and childs. Always pairs up with the "
	"recoiling pt, and should get the phase space and ordering "
	"correct, but makes the emissions depend on the history"
	", not only current state.",
	1);
	static SwitchOption interfaceEffectivePartonModeShadows
	(interfaceEffectivePartonMode,
	"Shadows",
	"Don't use Effective partons, use shadow partons instead.",
	-1);
	static SwitchOption interfaceEffectivePartonModeNewShadows
	(interfaceEffectivePartonMode,
	"NewShadows",
	"Don't use Effective partons, use shadow partons instead.",
	-2);

	static Switch<DipoleEventHandler,int> interfaceCollisionType
	("CollisionType",
	"What type of collison.",
	&DipoleEventHandler::theCollisionType, 0, true, false);
	static SwitchOption interfaceCollisionTypeNonDiffractive
	(interfaceCollisionType,
	"NonDiffractive",
	"Should be self explanatory. :P",
	0);
	static SwitchOption interfaceTypeSingleDiffractive
	(interfaceCollisionType,
	"SingleDiffractive",
	"Should be self explanatory. :P",
	1);

	static Parameter<DipoleEventHandler,bool> interfaceShowHistory
	("ShowHistory",
	"If the history of every event should be studied manually."
	"Note that only final state events get studied, not the presamples.",
	&DipoleEventHandler::doShowHistory, false, false, false,
	true, false, Interface::lowerlim);

	static Parameter<DipoleEventHandler,Energy> interfaceLambdaQCD
	("LambdaQCD",
	"The value of \\f$\\Lambda_{QCD}\\f$ to be used in the running coupling. "
	"If zero, the <interface>AlphaS</interface> object will be used for the "
	"coupling instead.",
	&DipoleEventHandler::theLambdaQCD, GeV, 0.22GeV, 0.0GeV, 0*GeV,
	true, false, Interface::lowerlim);

	static Parameter<DipoleEventHandler,double> interfaceFixedAlphaS
	("FixedAlphaS",
	"The value of the constant coupling. If zero, a running coupling is "
	"assumed.",
	&DipoleEventHandler::theFixedAlphaS, 0.0, 0.0, 0,
	true, false, Interface::lowerlim);

	static Reference<DipoleEventHandler,AlphaSBase> interfaceExternalAlphaS
	("ExternalAlphaS",
	"An external \\f$\\alpha_S\\f$ object to be used if "
	"<interface>LambdaQCD</interface> is zero. If null the object "
	"specified in the overall StandardModel object will be used insted.",
	&DipoleEventHandler::theExternalAlphaS, true, false, true, true, false);

	static Parameter<DipoleEventHandler,int> interfaceNF
	("NF",
	"The number of flavours to be used in the running coupling. Not active "
	"if an external running coupling (<interface>ExternalAlphaS</interface> "
	"is used.",
	&DipoleEventHandler::theNF, 3, 1, 0,
	true, false, Interface::lowerlim);

	static Reference<DipoleEventHandler,WaveFunction> interfaceWFR
	("WFR",
	"The wave function of the incoming particle along the positive z-axis.",
	&DipoleEventHandler::theWFR, true, false, true, false, false);

	static Reference<DipoleEventHandler,WaveFunction> interfaceWFL
	("WFL",
	"The wave function of the incoming particle along the negative z-axis.",
	&DipoleEventHandler::theWFL, true, false, true, false, false);

	static Parameter<DipoleEventHandler,double> interfaceYFrame
	("YFrametest",
	"Indicate in which frame the dipole systems should collide. A value of "
	"0.5 means that both systems will be evolved an equal rapidity distance. "
	"0.0 (1.0) means that the right(left)-moving system will not be evolved "
	"at all while the left(right)-moving system will be evolved as much as "
	"possible. A value larger than 1.0 (less than 0.0) means the right-(left-)moving "
	"system will be evolved a fixed rapidity interval YFrametest - 1 (-YFrametest)",
	&DipoleEventHandler::theYFrame, 0.5, 0.0, 1.0,
	true, false, Interface::nolimits);


	static Switch<DipoleEventHandler,int> interfaceFudgeME
	("FudgeME",
	"Indicate whether a fudge factor should be included to tame the high-pt tail "
	"according to an approximate matrix element correction.",
	&DipoleEventHandler::theFudgeME, 0, true, false);
	static SwitchOption interfaceFudgeMEFudge
	(interfaceFudgeME,
	"Fudge",
	"Include fudge factor",
	1);
	static SwitchOption interfaceFudgeMEFudgeC
	(interfaceFudgeME,
	"Fudge",
	"Include fudge factor and make cross section dependent on the colour "
	"indices of the colliding dipoles",
	2);
	static SwitchOption interfaceFudgeMENoFudge
	(interfaceFudgeME,
	"NoFudge",
	"Do not include fudge factor",
	0);


	static Parameter<DipoleEventHandler,double> interfaceFudgeFactorME
	("FudgeFactorME",
	"Extra factor to be applied for high-pt scattering in interactions.",
	&DipoleEventHandler::theFudgeFactorME, 1.0, 0.0, 0,
	true, false, Interface::lowerlim);


	static Parameter<DipoleEventHandler,int> interfacePreSamples
	("PreSamples",
	"The number of collisions to analyze in the presampling.",
	&DipoleEventHandler::thePreSamples, 1000, 0, 0,
	true, false, Interface::lowerlim);

	static Parameter<DipoleEventHandler,int> interfacePreSampleL
	("PreSampleL",
	"The number of left-moving systems to generate for each presample.",
	&DipoleEventHandler::thePreSampleL, 1, 1, 0,
	true, false, Interface::lowerlim);

	static Parameter<DipoleEventHandler,int> interfacePreSampleR
	("PreSampleR",
	"The number of right-moving systems to generate for each presample.",
	&DipoleEventHandler::thePreSampleR, 1, 1, 0,
	true, false, Interface::lowerlim);

	static Parameter<DipoleEventHandler,int> interfacePreSampleB
	("PreSampleB",
	"The number ofimpact parameters to generate for each presample.",
	&DipoleEventHandler::thePreSampleB, 1, 1, 0,
	true, false, Interface::lowerlim);

	static Reference<DipoleEventHandler,DipoleXSec> interfaceXSecFn
	("XSecFn",
	"The object responsible for calculating the cross section for two "
	"colliding dipole systems.",
	&DipoleEventHandler::theXSecFn, true, false, true, false, false);

	static Reference<DipoleEventHandler,ImpactParameterGenerator> interfaceBGen
	("BGen",
	"The object responsible for generating the impact parameters.",
	&DipoleEventHandler::theBGen, true, false, true, false, false);

	static Reference<DipoleEventHandler,Emitter> interfaceEmitter
	("Emitter",
	"The object responsible for generating and performing dipole emissions "
	"of gluons.",
	&DipoleEventHandler::theEmitter, true, false, true, false, false);

	static Reference<DipoleEventHandler,Swinger> interfaceSwinger
	("Swinger",
	"The object responsible for generating and performing dipole swings.",
	&DipoleEventHandler::theSwinger, true, false, true, true, false);

	static Reference<DipoleEventHandler,EventFiller> interfaceEventFiller
	("EventFiller",
	"The object responsible for filling an event with final state gluons.",
	&DipoleEventHandler::theEventFiller, true, false, true, false, false);

	static RefVector<DipoleEventHandler,DipoleAnalysisHandler>
	interfaceAnalysisHandlers
	("AnalysisHandlers",
	"A list of analysis to be performed in the presample phase.",
	&DipoleEventHandler::analyses, -1, true, false, true, false, false);


	static Parameter<DipoleEventHandler,InvEnergy> interfaceBaryonSize
	("BaryonSize",
	"The typical size of a baryon to be used by wave functions not "
	"defining their own. If zero, <interface>RMax</interface> will "
	"be used instead.",
	&DipoleEventHandler::theBaryonSize, InvGeV, 0.0InvGeV, 0.0InvGeV, 0*InvGeV,
	true, false, Interface::lowerlim);

	}

	diff --git a/DIPSY/DipoleEventHandler.h b/DIPSY/DipoleEventHandler.h
	--- a/DIPSY/DipoleEventHandler.h
	+++ b/DIPSY/DipoleEventHandler.h
	@@ -1,618 +1,632 @@
	// -- C++ --
	#ifndef DIPSY_DipoleEventHandler_H
	#define DIPSY_DipoleEventHandler_H
	//
	// This is the declaration of the DipoleEventHandler class.
	//

	#include "ThePEG/Handlers/EventHandler.h"
	#include "DipoleEventHandler.fh"
	#include "WaveFunction.h"
	#include "DipoleXSec.h"
	#include "Emitter.h"
	#include "Swinger.h"
	#include "EventFiller.h"
	// #include "DiffractiveEventFiller.h"
	#include "ImpactParameterGenerator.h"
	#include "DipoleAnalysisHandler.h"
	#include "ThePEG/StandardModel/AlphaSBase.h"
	#include "ThePEG/StandardModel/StandardModelBase.h"
	#include "ThePEG/Utilities/XSecStat.h"

	namespace DIPSY {

	using namespace ThePEG;

	/**
	* Here is the documentation of the DipoleEventHandler class.
	*
	* @see \ref DipoleEventHandlerInterfaces "The interfaces"
	* defined for DipoleEventHandler.
	*/
	class DipoleEventHandler: public EventHandler {

	public:

	/** Declare a pointer to an AlphaSBase object. */
	typedef Ptr<AlphaSBase>::pointer ASPtr;

	public:

	/** @name Standard constructors and destructors. */
	//@{
	/**
	* The default constructor.
	*/
	DipoleEventHandler();

	/**
	* The destructor.
	*/
	virtual ~DipoleEventHandler();
	//@}

	public:

	/**
	* Initialize this event handler and all related objects needed to
	* generate events.
	*/
	virtual void initialize();

	/**
	* Pre-sample the cross section before generating events.
	* This does inclusive cross section for non-diffractive collisions.
	* Diffractive inclusive cross sections are redirected.
	*/
	void presample();

	/**
	* Pre-sample the single diffractive cross section before
	* generating events. This requires a different method, as it
	* needs a double loop over events.
	*/
	void diffractivePresample();

	/**
	* Generate an event.
	*/
	virtual EventPtr generateEvent();

	/**
	* Generate a diffractive event.
	*/
	virtual EventPtr generateDiffractiveEvent();

	/**
	* Write out statistics.
	*/
	virtual void statistics(ostream &) const;

	/**
	* The total integrated cross section of the processes generated in
	* this run.
	* @return 0 if no integrated cross section could be estimated.
	*/
	virtual CrossSection integratedXSec() const;

	/**
	* The error total integrated cross section of the processes
	* generated in this run.
	* @return 0 if no integrated cross section could be estimated.
	*/
	virtual CrossSection integratedXSecErr() const;

	/**
	* The overestimated cross section ised in the generation.
	*/
	CrossSection maxXSec() const;

	/**
	* Histogram scale. A histogram bin which has been filled with the
	* weights associated with the Event objects should be scaled by
	* this factor to give the correct cross section.
	*/
	virtual CrossSection histogramScale() const;

	/**
	* Return the running coupling for the given size (scale).
	*/
	double alphaS(InvEnergy r) const;

	/** @name Simple access functions. */
	//@{
	/**
	* The number of different colour indices.
	*/
	inline int nColours() const {
	return theNColours;
	}

	/**
	* The general hadronic size.
	*/
	inline InvEnergy rMax() const {
	return theRMax;
	}

	/**
	* Get the typical size of a baryon to be used by wave functions not
	* defining their own.
	*/
	inline InvEnergy baryonSize() const {
	return theBaryonSize > ZERO? theBaryonSize: rMax();
	}

	/**
	* The maximum range at which coherent emissions are allowed.
	*/
	inline InvEnergy coherenceRange() const {
	return theCoherenceRange;
	}

	/**
	* Return the effective parton mode.
	*/
	inline int effectivePartonMode() const {
	return theEffectivePartonMode;
	}

	/**
	* Return the collision type.
	*/
	inline int collisionType() const {
	return theCollisionType;
	}

	/**
	* The value of \f$\Lambda_{QCD}\f$ to be used in the running coupling.
	*/
	inline Energy LambdaQCD() const {
	return theLambdaQCD;
	}

	/**
	* The number of flavours to be used in the running coupling.
	*/
	inline int nF() const {
	return theNF;
	}

	/**
	* The value of the constant coupling. If zero, a running coupling is assumed.
	*/
	inline double fixedAlphaS() const {
	return theFixedAlphaS;
	}

	/**
	* An external \f$\alpha_S\f$ object to be used if LambdaQCD() is zero.
	*/
	inline ASPtr externalAlphaS() const {
	return theExternalAlphaS;
	}

	/**
	* Alpha bar = alphas*Nc/pi
	*/
	inline double alphaBar(InvEnergy r) const {
	return alphaS(r)*3.0/M_PI;
	}

	/**
	* Get the wave function of the incoming particle along the positive z-axis.
	*/
	inline WaveFunction & WFR() const {
	return *theWFR;
	}

	/**
	* Get the wave function of the incoming particle along the negative z-axis.
	*/
	inline WaveFunction & WFL() const {
	return *theWFL;
	}

	/**
	* Get the object responsible for generating the impact parameters.
	*/
	inline const ImpactParameterGenerator & bGen() const {
	return *theBGen;
	}

	/**
	* Indicate whether a fudge factor should be included to tame the
	* high-pt tail according to an approximate matrix element
	* correction.
	*/
	inline int fudgeME() const {
	return theFudgeME;
	}

	/**
	* Indicate whether an additional fudge factor should be included to tame the
	* high-pt tail in the interactions.
	*/
	inline double fudgeFactorME() const {
	return theFudgeFactorME;
	}

	/**
	* Indicate in which frame the dipole systems should collide.
	*/
	inline double yFrame() const {
	return theYFrame;
	}

	/**
	* Return the rapidity to use for the interaction frame.
	*/
	double interactionFrame(double ymin, double ymax) const;

	/**
	* Get the number of collisions to analyze in the presampling.
	*/
	inline int preSamples() const {
	return thePreSamples;
	}

	/**
	* The number of left-moving systems to generate for each presample.
	*/
	inline int preSampleL() const {
	return thePreSampleL;
	}

	/**
	* The number of right-moving systems to generate for each presample.
	*/
	inline int preSampleR() const {
	return thePreSampleR;
	}

	/**
	* The number of impact parameters to generate for each presample.
	*/
	inline int preSampleB() const {
	return thePreSampleB;
	}

	/**
	* Get the object responsible for calculating the cross section for
	* two colliding dipole systems.
	*/
	inline const DipoleXSec & xSecFn() const {
	return *theXSecFn;
	}

	/**
	* Get the object responsible for generating and performing dipole
	* emissions of gluons.
	*/
	inline const Emitter & emitter() const {
	return *theEmitter;
	}

	/**
	+ * Get the scale used to convert between impact parameters and
	+ * transverse momenta.
	+ */
	+ double pTScale() const {
	+ return thePTScale > 0? thePTScale: emitter().pTScale();
	+ }
	+
	+ /**
	* Set the object responsible for generating and performing dipole
	* emissions of gluons.
	* Added by CF to access from emitter.
	*/
	inline void emitter(EmitterPtr em) {
	theEmitter = em;
	}

	/**
	* Set the object responsible for generating and performing dipole
	* swings.
	* Added by CF to access from emitter.
	*/
	inline void swinger(SwingerPtr sw) {
	theSwinger = sw;
	}

	/**
	* Get the object responsible for generating and performing dipole swings.
	*/
	inline const Swinger & swinger() const {
	return *theSwinger;
	}

	/**
	* Get the object responsible for generating and performing dipole swings.
	*/
	inline tSwingerPtr swingPtr() const {
	return theSwinger;
	}

	/**
	* Get the object responsible for filling an event with final state gluons.
	*/
	inline const EventFiller & eventFiller() const {
	return *theEventFiller;
	}

	// /**
	// * Get the object responsible for filling an event with final state gluons.
	// */
	// inline const DiffractiveEventFiller & diffractiveEventFiller() const {
	// return *theDiffractiveEventFiller;
	// };

	/**
	* adds an error to the counter
	**/
	inline void err() const {
	theNErr++;
	};

	/**
	* returns teh number of errors so far.
	**/
	inline const long nErr() const {
	return theNErr;
	};
	//@}

	public:

	/** @name Functions used by the persistent I/O system. */
	//@{
	/**
	* Function used to write out object persistently.
	* @param os the persistent output stream written to.
	*/
	void persistentOutput(PersistentOStream & os) const;

	/**
	* Function used to read in object persistently.
	* @param is the persistent input stream read from.
	* @param version the version number of the object when written.
	*/
	void persistentInput(PersistentIStream & is, int version);
	//@}

	/**
	* The standard Init function used to initialize the interfaces.
	* Called exactly once for each class by the class description system
	* before the main function starts or
	* when this class is dynamically loaded.
	*/
	static void Init();

	protected:

	/** @name Clone Methods. */
	//@{
	/**
	* Make a simple clone of this object.
	* @return a pointer to the new object.
	*/
	virtual IBPtr clone() const;

	/** Make a clone of this object, possibly modifying the cloned object
	* to make it sane.
	* @return a pointer to the new object.
	*/
	virtual IBPtr fullclone() const;
	//@}


	// If needed, insert declarations of virtual function defined in the
	// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).

	private:

	/**
	* The number of different colour indices.
	*/
	int theNColours;

	/**
	* The general hadronic size.
	*/
	InvEnergy theRMax;

	/**
	+ * The scale used to relate impactparameter distances and transverse
	+ * momenta.
	+ */
	+ double thePTScale;
	+
	+ /**
	* The typical size of a baryon to be used by wave functions not
	* defining their own. If zero, theRMax will be used instead.
	*/
	InvEnergy theBaryonSize;

	/**
	* The maximum range at which partons can emit coherently as effective partons.
	*/
	InvEnergy theCoherenceRange;

	/**
	* The way the partons are grouped into effective partons.
	*/
	int theEffectivePartonMode;

	/**
	* The type of collison. 0: non diffractive, 1: single diffractive
	*/
	int theCollisionType;

	/**
	* if the history of every event should be studied manually.
	*/
	bool doShowHistory;

	/**
	* The value of \f$\Lambda_{QCD}\f$ to be used in the running coupling.
	*/
	Energy theLambdaQCD;

	/**
	* The number of flavours to be used in the running coupling.
	*/
	int theNF;

	/**
	* The value of the constant coupling. If zero, a running coupling is assumed.
	*/
	double theFixedAlphaS;

	/**
	* An external \f$\alpha_S\f$ object to be used if LambdaQCD() is zero.
	*/
	ASPtr theExternalAlphaS;

	/**
	* The wave function of the incoming particle along the positive z-axis.
	*/
	WaveFunctionPtr theWFR;

	/**
	* The wave function of the incoming particle along the negative z-axis.
	*/
	WaveFunctionPtr theWFL;

	/**
	* The object responsible for generating the impact parameters.
	*/
	ImpactParameterGeneratorPtr theBGen;

	/**
	* Indicate in which frame the dipole systems should collide.
	*/
	double theYFrame;

	/**
	* Indicate whether a fudge factor should be included to tame the
	* high-pt tail according to an approximate matrix element correction,
	* and, if so, should the dipole colours be taken into account.
	*/
	int theFudgeME;

	/**
	* Indicate whether an extra fudge factor should be included to tame
	* the high-pt tail in the interactions according to an approximate
	* matrix element correction.
	*/
	double theFudgeFactorME;

	/**
	* The number of collisions to analyze in the presampling.
	*/
	int thePreSamples;

	/**
	* The number of left-moving systems generated for each presample.
	*/
	int thePreSampleL;

	/**
	* The number of right-moving systems generated for each presample.
	*/
	int thePreSampleR;

	/**
	* The number of impact parameters generated for each presample.
	*/
	int thePreSampleB;

	/**
	* The object responsible for calculating the cross section for two
	* colliding dipole systems.
	*/
	DipoleXSecPtr theXSecFn;

	/**
	* The object responsible for generating and performing dipole
	* emissions of gluons.
	*/
	EmitterPtr theEmitter;

	/**
	* The object responsible for generating and performing dipole swings.
	*/
	SwingerPtr theSwinger;

	/**
	* The object responsible for filling an event with final state gluons.
	*/
	EventFillerPtr theEventFiller;

	// /**
	// * The object responsible for filling an event with diffractive final state gluons.
	// */
	// DiffractiveEventFillerPtr theDiffractiveEventFiller;

	/**
	* A list of analysis objects to be applied in the presample phase.
	*/
	vector<DipoleAnalysisHandlerPtr> analyses;

	/**
	* Collect statistics.
	*/
	XSecStat stats;

	/**
	* The number of error messages.
	**/
	mutable long theNErr;


	protected:

	/** @name Standard Interfaced functions. */
	//@{
	/**
	* Initialize this object after the setup phase before saving an
	* EventGenerator to disk.
	* @throws InitException if object could not be initialized properly.
	*/
	virtual void doinit() throw(InitException);

	/**
	* Initialize this object. Called in the run phase just before
	* a run begins.
	*/
	virtual void doinitrun();

	/**
	* Finalize this object. Called in the run phase just after a
	* run has ended. Used eg. to write out statistics.
	*/
	virtual void dofinish();

	/**
	* Rebind pointer to other Interfaced objects. Called in the setup phase
	* after all objects used in an EventGenerator has been cloned so that
	* the pointers will refer to the cloned objects afterwards.
	* @param trans a TranslationMap relating the original objects to
	* their respective clones.
	* @throws RebindException if no cloned object was found for a given
	* pointer.
	*/
	virtual void rebind(const TranslationMap & trans) throw(RebindException);

	/**
	* Return a vector of all pointers to Interfaced objects used in this
	* object.
	* @return a vector of pointers.
	*/
	virtual IVector getReferences();
	//@}

	public:

	/** Return the elapsed number of seconds since lat call. */
	static double elapsed();

	private:

	/**
	* The assignment operator is private and must never be called.
	* In fact, it should not even be implemented.
	*/
	DipoleEventHandler & operator=(const DipoleEventHandler &);

	};

	}

	#endif /* DIPSY_DipoleEventHandler_H */
	diff --git a/DIPSY/PPTune/PPTune.inc b/DIPSY/PPTune/PPTune.inc
	--- a/DIPSY/PPTune/PPTune.inc
	+++ b/DIPSY/PPTune/PPTune.inc
	@@ -1,595 +1,606 @@
	# -- eval: (ThePEG-repository-mode) --
	# HOW TO TUNE
	#
	# We need to generate a number of yoda files for different energies
	# different observables and different parameter settings. This can be
	# done in an semi-automated way.
	#
	# For the total and elastic cross sections we do not need to generate
	# final states and these runs can in principle be done once and for
	# all. In fact running PP16XSECYM??.run (generated in the SAVERUNYM
	# just after the line "# 16 inclusive observables" below) will produce
	# all necessary data.
	#
	# This input file is (to make a gross understatement) a terrible
	# mess. It needs to beprocessed by the script ./expand.pl before going
	# to setupThePEG and it will produce an awfull amount of .run
	# files. However doing eg.
	# > make blaha
	# in this directory yo will only produce the .run files matching "blaha".
	#
	# For the final state you have to run the files generated after the
	# line "# 16 final state observables" below. You will have one run per
	# energy in PP16XSECYM@??.run (where @ is some arbitrary letter used
	# to differentiate between settings). The 7TeV will take quite a while
	# so it is best to divide it up in smaller runs. Using the scripts
	# "sub" and "runtag" in ~leif/bin you can start the programs as
	# follows:
	#
	# > sub runtag ./runThePEG, PP16XSECYM@02, PP16XSECYM@09,
	# PP16XSECYM@71_61-80, PP16XSECYM@71_41-60,
	# PP16XSECYM@71_21-40, PP16XSECYM@71_1-20
	# PP16XSECYM@71_81-100
	#
	# After these runs are done you can start the actual tuning with
	# professor. First you need to copy the relevant files from the
	# inclusive runs to match the names of the final states runs as
	# follows:
	# > cp PP16XSECYM01.log PP16XSECYM@01.log
	# > cp PP16XSECYM05.log PP16XSECYM@05.log
	# > cp PP16XSECYM18.log PP16XSECYM@18.log
	# > cp PP16XSECYM70.log PP16XSECYM@70.log
	# then run the mkprof.pl script as follows to get a "global" tune
	#
	# > ./mkprof.pl -t -w PPTuneFS00.weights -o PP16XSECYM@00.prof PP16XSECYM@
	# preferably redirecting both stdout and stderr to some file (there
	# will be a lot of output). Similarly
	# > ./mkprof.pl -t -w PPTuneFS70.weights -o PP16XSECYM@70.prof PP16XSECYM@

	# will give the tune restricting the final state data to 7TeV, and
	# changing all "70" to "09" or "02" will give 900 GeV or 200 GeV to
	# look at the result check the file
	# PP16XSECYM@00.prof/tunes/results.pkl or use the following script
	# > ./profsum.pl PP16XSECYM@00.prof/tunes/results.pkl
	# To get just a summary.
	#
	# After the line "# 16 pipeing the tunes" below you can then pipe the
	# different tunes, just set the parameters according to the fit, do
	# > make PPT16XSECYM@
	# and run eg.
	# > sub runtag ./runThePEG, PPT16XSECYM@02, PPT16XSECYM@09, PPT16XSECYM@71,
	# PPT16XSECYM@0202, PPT16XSECYM@0909, PPT16XSECYM@7170
	#
	#
	#
	#
	cd /DIPSY

	## First we setup some previously tuned tuned parameters
	#read CurrentTune.in
	read ../Tune31.in

	## Now we set up an event generator.
	cp EventHandler PPEventHandler
	set stdProton:R0 0.0
	set stdAntiProton:R0 0.0
	set Proton:R0 0.0
	set AntiProton:R0 0.0
	set PPEventHandler:WFL stdProton
	set PPEventHandler:WFR stdProton
	set PPEventHandler:ConsistencyLevel 1
	set PPEventHandler:XSecFn:CheckOffShell false
	set PPEventHandler:CascadeHandler AriadneCascade
	set PPEventHandler:HadronizationHandler Frag8
	set PPEventHandler:DecayHandler /Defaults/Handlers/StandardDecayHandler
	create ThePEG::FixedCMSLuminosity PPLumi
	set PPEventHandler:LuminosityFunction PPLumi
	cp Generator PPGenerator
	erase PPGenerator:AnalysisHandlers[0]
	set PPGenerator:HistogramFactory NULL
	set PPGenerator:EventHandler PPEventHandler
	set PPEventHandler:BGen:Width 5
	set PPEventHandler:WFL Proton
	set PPEventHandler:WFR Proton
	set PPEventHandler:EventFiller:SoftRemove NoValence
	set PPEventHandler:FudgeME 1
	set PPEventHandler:EventFiller:PTCut 1.0
	set FSOrdering:PTMin 1.0
	set PPEventHandler:Emitter:PSInflation 1.0
	set PPEventHandler:Swinger:Lambda 1.0
	set PPEventHandler:EffectivePartonMode Colours
	set PPEventHandler:CoherenceRange 2.5

	## These are the analysess we will run
	## Some semi-inclusive cross section for DIPSY which need at least
	## four combinations of left- and right-moving cascades.
	erase PPEventHandler:AnalysisHandlers[0]
	erase PPEventHandler:AnalysisHandlers[0]
	create DIPSY::SemiInclusiveXSecAnalysis SemiIncl SemiInclusiveXSecAnalysis.so
	insert PPEventHandler:AnalysisHandlers[0] SemiIncl
	set PPEventHandler:PreSampleL 2
	set PPEventHandler:PreSampleR 2
	## This is just to keep track of the progress of a run
	create DIPSY::AnalysisProgress AnaLog AnalysisProgress.so
	set AnaLog:Interval 600
	insert PPEventHandler:AnalysisHandlers[0] AnaLog

	## The sample rates need to be adjusted so that we get a reasonable
	## statistics in a reasonable time. It is typically efficient to
	## sample a number of impact parameter values for each pair of DIPSY
	## cascades.
	set PPEventHandler:PreSampleB 1

	## We need the same set of parameters for all different energies, so
	## we use a separate random generator.
	cp /Defaults/Random RandomArg
	set PPGenerator:SeparateRandom RandomArg

	## These are the parameters we want to tune

	## Now we want to run for all energies and two values for YFrametest

	set Frag8:Collapser /Ariadne5/Defaults/Collapser

	# This is the fragmentation parameters tuned without rope and with swing at LEP
	# ../../src/FTuneSwLEP01.prin
	set Frag8:FragmentationScheme none
	set Frag8:StringZ_aLund 0.42
	set Frag8:StringZ_bLund 0.40
	set Frag8:StringPT_sigma 0.32
	set Frag8:StringFlav_probQQtoQ 0.084
	set Frag8:StringFlav_probStoUD 0.22

	# This is the fragmentation parameters tuned without rope and swing at LEP
	# ../../src/FTuneLEP01.prin
	cp Frag8 Frag8Sw0
	set Frag8Sw0:StringZ_aLund 0.30
	set Frag8Sw0:StringZ_bLund 0.36
	set Frag8Sw0:StringPT_sigma 0.32
	set Frag8Sw0:StringFlav_probQQtoQ 0.082
	set Frag8Sw0:StringFlav_probStoUD 0.22

	# TEST fragmentation parameters tuned at LEP without rope and swing with MaxRho = 1
	# ../../src/FTuneswLEP03.prin
	cp Frag8 Frag8Sw2
	set Frag8Sw2:StringZ_aLund 0.45
	set Frag8Sw2:StringZ_bLund 0.42
	set Frag8Sw2:StringPT_sigma 0.32
	set Frag8Sw2:StringFlav_probQQtoQ 0.085
	set Frag8Sw2:StringFlav_probStoUD 0.22

	# This is the fragmentation parameters tuned to rope and default swing at LEP
	# ../../src/FTuneSwLEP07.prin
	cp Frag8 Frag8Rope
	set Frag8Rope:FragmentationScheme dipole
	set Frag8Rope:StringR0 1.0
	set Frag8Rope:Stringm0 0.2
	set Frag8Rope:Average false
	set Frag8Rope:ThrowAway true
	set Frag8Rope:BaryonSuppression 0.25
	set Frag8Rope:StringZ_aLund 0.41
	set Frag8Rope:StringZ_bLund 0.37
	set Frag8Rope:StringPT_sigma 0.31
	set Frag8Rope:StringFlav_probQQtoQ 0.073
	set Frag8Rope:StringFlav_probStoUD 0.21

	cp AriadneCascade AriadneNoSwing
	erase AriadneNoSwing:Emitters[0]
	set PPGenerator:EventHandler:PreSamples 0
	set PPGenerator:EventHandler:YFrametest 0.5
	set /DIPSY/PPEventHandler:BaryonSize 0.0
	set FSSwinger:SetRmax -2.7
	set FSSwinger:MaxRho -2.0




	create ThePEG::ProgressLog Logger ProgressLog.so
	set Logger:Interval 600
	create ThePEG::RivetAnalysis RivetTune RivetAnalysis.so
	insert RivetTune:Paths[0] .
	insert RivetTune:Analyses[0] ATLAS_2010_S8918562
	insert RivetTune:Analyses[0] STAR_2008_S7869363
	insert RivetTune:Analyses[0] CMS_2011_S8978280
	insert RivetTune:Analyses[0] PYTHIA_TUNING

	insert PPGenerator:AnalysisHandlers[0] Logger
	insert PPGenerator:AnalysisHandlers[0] RivetTune





	set PPGenerator:EventHandler:LuminosityFunction:Energy 7000
	set PPGenerator:DumpPeriod 0
	cp PPGenerator PPTestTune
	set PPGenerator:NumberOfEvents 10000

	set PPTestTune:NumberOfEvents 100000
	create ThePEG::LWHFactory LWHFactory LWHFactory.so
	set LWHFactory:Suffix dat
	set LWHFactory:StoreType flat
	set PPTestTune:HistogramFactory LWHFactory
	create DIPSY::PTAnalysis PTAnalysis PTAnalysis.so
	insert PPTestTune:AnalysisHandlers[0] PTAnalysis

	do PPGenerator:AddRndInterface /DIPSY/PPEventHandler:RMax 100 1.0 5.0 2.9 0.6
	do PPGenerator:AddRndInterface /DIPSY/PPEventHandler:LambdaQCD 1 0.10 0.3 0.22 0.04
	do PPGenerator:AddRndInterface /DIPSY/PPEventHandler:Emitter:PTScale 1 0.5 2.5 1.4 0.5
	do PPGenerator:AddRndInterface /DIPSY/PPEventHandler:Emitter:PMinusOrdering 1 0.5 2.0 1.0 0.2

	cp PPGenerator PPXSecGenerator
	erase PPXSecGenerator:AnalysisHandlers[0]
	erase PPXSecGenerator:AnalysisHandlers[0]
	create ThePEG::Settings OnlyXSec
	do OnlyXSec:set PPXSecGenerator:EventHandler:PreSamples 1000
	insert PPXSecGenerator:DefaultObjects[0] OnlyXSec
	set PPXSecGenerator:NumberOfEvents 0
	cp OnlyXSec AddXSec
	insert PPTestTune:DefaultObjects[0] AddXSec


	create ThePEG::Settings Default
	cp Default NoSwing
	cp Default DefRope

	do Default:set PPEventHandler:HadronizationHandler Frag8
	do Default:set PPEventHandler:CascadeHandler AriadneCascade
	do NoSwing:set PPEventHandler:HadronizationHandler Frag8Sw0
	do NoSwing:set PPEventHandler:CascadeHandler AriadneNoSwing
	do DefRope:set PPEventHandler:HadronizationHandler Frag8Rope
	do DefRope:set PPEventHandler:CascadeHandler AriadneCascade

	insert PPGenerator:DefaultObjects[0] Default
	insert PPXSecGenerator:DefaultObjects[0] Default
	insert PPTestTune:DefaultObjects[0] Default

	cp Default NewSing
	do NewSing:set PPEventHandler:EventFiller:Mode NewSingle
	do NewSing:set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	do NewSing:set PPEventHandler:FudgeME 2
	do NewSing:set PPEventHandler:XSecFn:SinFunction Average

	cp Default NewSinF
	do NewSinF:set PPEventHandler:XSecFn:SinFunction Average

	cp Default NewSinS
	do NewSinS:set PPEventHandler:XSecFn:SinFunction Scaled

	cp Default EffPRel
	do EffPRel:set PPEventHandler:EffectivePartonMode Relatives

	cp Default DefaY7F
	do DefaY7F:set PPGenerator:EventHandler:YFrametest 0.7

	cp DefaY7F Def01Y7
	do Def01Y7:set PPEventHandler:Swinger:Lambda 0.1

	cp Default DefEven
	do DefEven:set PPEventHandler:EventFiller:EffectiveWeights PlusEvenWeighted

	cp Default DefSwL4
	do DefSwL4:set PPEventHandler:Swinger:Lambda 4.0

	cp Default DefSw01
	do DefSw01:set PPEventHandler:Swinger:Lambda 0.1

	cp Default DefFSGO
	do DefFSGO:set FSOrdering:Generous Generous
	do DefFSGO:set FSOrdering:OnlyOriginal OnlyOriginalEmissions

	cp DefFSGO DefFSG2
	do DefFSG2:set FSOrdering:Fudge 1.6

	cp Default Shadows
	do Shadows:set PPEventHandler:EffectivePartonMode Shadows

	cp Default DefSing
	do DefSing:set PPEventHandler:FudgeME 2
	do DefSing:set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	do DefSing:set PPTestTune:EventHandler:EventFiller:SingleMother 1

	cp DefSing DefComp
	do DefComp:set PPTestTune:EventHandler:EventFiller:CompatMode 1

	cp Default Shadow8
	do Shadow8:set PPEventHandler:EffectivePartonMode Shadows
	do Shadow8:set PPEventHandler:FudgeME 2
	do Shadow8:set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	do Shadow8:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do Shadow8:set stdEmitter:MinusOrderingMode OrderedShadow
	do Shadow8:set stdXSec:IntOrdering ShadowOpen

	cp Default Shadow9
	do Shadow9:set PPEventHandler:EffectivePartonMode Shadows
	do Shadow9:set PPEventHandler:FudgeME 2
	do Shadow9:set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	do Shadow9:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do Shadow9:set stdEmitter:MinusOrderingMode OrderedShadow
	do Shadow9:set stdXSec:IntOrdering ShadowColour

	cp Default ShadowA
	do ShadowA:set PPEventHandler:EffectivePartonMode Shadows
	do ShadowA:set PPEventHandler:FudgeME 2
	do ShadowA:set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	do ShadowA:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do ShadowA:set stdEmitter:MinusOrderingMode UnrderedShadow
	do ShadowA:set stdXSec:IntOrdering ShadowColour
	# cp ShadowA ShadowB the former is with new setEmissionMomentum (-DDIPSY::PlusEvo)
	# cp ShadowA ShadowC the former with small bugfix?

	cp Default ShadowD
	do ShadowD:set PPEventHandler:EffectivePartonMode Shadows
	do ShadowD:set PPEventHandler:FudgeME 2
	do ShadowD:set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	do ShadowD:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do ShadowD:set stdEmitter:MinusOrderingMode CutShadow
	do ShadowD:set stdXSec:IntOrdering ShadowColourMax

	cp Default ShadowE
	do ShadowE:set PPEventHandler:EffectivePartonMode Shadows
	do ShadowE:set PPEventHandler:FudgeME 2
	do ShadowE:set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	do ShadowE:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do ShadowE:set stdEmitter:MinusOrderingMode CutShadow
	do ShadowE:set stdXSec:IntOrdering ShadowColourMax
	do ShadowE:set stdXSec:RMax -1.0
	cp Default ShadowF
	do ShadowF:set PPEventHandler:EffectivePartonMode Shadows
	do ShadowF:set PPEventHandler:FudgeME 2
	do ShadowF:set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	do ShadowF:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do ShadowF:set stdEmitter:MinusOrderingMode CutShadow
	do ShadowF:set stdXSec:IntOrdering ShadowColourMax
	do ShadowF:set stdXSec:SinFunction Scaled
	do ShadowF:set stdXSec:RMax -1.0
	cp Default ShadowG
	do ShadowG:set PPEventHandler:EffectivePartonMode Shadows
	do ShadowG:set PPEventHandler:FudgeME 2
	do ShadowG:set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	do ShadowG:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do ShadowG:set stdEmitter:MinusOrderingMode CutShadow
	do ShadowG:set stdXSec:IntOrdering ShadowColourMax
	do ShadowG:set stdXSec:PTScale 1.0
	do ShadowG:set stdXSec:RMax -1.0
	cp Default ShadowH
	do ShadowH:set PPEventHandler:EffectivePartonMode Shadows
	do ShadowH:set PPEventHandler:FudgeME 2
	do ShadowH:set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	do ShadowH:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do ShadowH:set stdEmitter:MinusOrderingMode CutShadow
	do ShadowH:set stdXSec:IntOrdering ShadowColourMax
	cp Default ShadowI
	do ShadowI:set PPEventHandler:EffectivePartonMode Shadows
	do ShadowI:set PPEventHandler:FudgeME 2
	do ShadowI:set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	do ShadowI:set PPTestTune:EventHandler:EventFiller:SingleMother 1
	do ShadowI:set stdEmitter:MinusOrderingMode HalfShadow
	do ShadowI:set stdXSec:IntOrdering ShadowColourMax



	cp Default Defaupt
	do Defaupt:set PPTestTune:EventHandler:EventFiller:PTCut 2.0
	do Defaupt:set FSOrdering:PTMin 2.0

	# Run for tuning

	SAVERUNFSXD Default PPGenerator Default PPXSecGenerator
	SAVERUNFSXD DefRope PPGenerator Default PPXSecGenerator
	SAVERUNFSXD NoSwing PPGenerator Default PPXSecGenerator
	SAVERUNFSXD NewSinF PPGenerator NewSinF PPXSecGenerator
	SAVERUNFSXD NewSinS PPGenerator NewSinS PPXSecGenerator
	SAVERUNFSXD NewSing PPGenerator NewSing PPXSecGenerator
	SAVERUNFSXD EffPRel PPGenerator EffPRel PPXSecGenerator
	SAVERUNFSXD DefaY7F PPGenerator DefaY7F PPXSecGenerator
	SAVERUNFSXD Def01Y7 PPGenerator Def01Y7 PPXSecGenerator
	SAVERUNFSXD DefEven PPGenerator DefEven PPXSecGenerator
	SAVERUNFSXD DefSwL4 PPGenerator DefSwL4 PPXSecGenerator
	SAVERUNFSXD DefSw01 PPGenerator DefSw01 PPXSecGenerator
	SAVERUNFSXD DefFSGO PPGenerator Default PPXSecGenerator
	SAVERUNFSXD DefFSG2 PPGenerator Default PPXSecGenerator
	SAVERUNFSXD Shadows PPGenerator Shadows PPXSecGenerator
	SAVERUNFSXD DefSing PPGenerator DefSing PPXSecGenerator
	SAVERUNFSXD DefComp PPGenerator DefComp PPXSecGenerator
	SAVERUNFSXD Shadow8 PPGenerator Shadow8 PPXSecGenerator
	SAVERUNFSXD Shadow9 PPGenerator Shadow9 PPXSecGenerator
	SAVERUNFSXD ShadowA PPGenerator ShadowA PPXSecGenerator
	SAVERUNFSXD ShadowD PPGenerator ShadowD PPXSecGenerator
	SAVERUNFSXD Defaupt PPGenerator Defaupt PPXSecGenerator

	do PPGenerator:RemoveInterface /DIPSY/PPEventHandler:Emitter:PMinusOrdering
	do PPGenerator:AddRndInterface /DIPSY/PPEventHandler:Emitter:RMax 1 1.0 5.0 2.9 0.6
	do PPXSecGenerator:RemoveInterface /DIPSY/PPEventHandler:Emitter:PMinusOrdering
	do PPXSecGenerator:AddRndInterface /DIPSY/PPEventHandler:Emitter:RMax 1 1.0 5.0 2.9 0.6
	SAVERUNFSXD ShadowE PPGenerator ShadowE PPXSecGenerator
	SAVERUNFSXD ShadowF PPGenerator ShadowF PPXSecGenerator
	SAVERUNFSXD ShadowG PPGenerator ShadowG PPXSecGenerator

	do PPGenerator:RemoveInterface /DIPSY/PPEventHandler:Emitter:RMax
	do PPGenerator:AddRndInterface /DIPSY/PPEventHandler:BaryonSize 1 1.0 5.0 2.9 0.6
	do PPXSecGenerator:RemoveInterface /DIPSY/PPEventHandler:Emitter:RMax
	do PPXSecGenerator:AddRndInterface /DIPSY/PPEventHandler:BaryonSize 1 1.0 5.0 2.9 0.6
	SAVERUNFSXD ShadowH PPGenerator ShadowH PPXSecGenerator
	SAVERUNFSXD ShadowI PPGenerator ShadowI PPXSecGenerator

	# testing the tunes

	SAVERUNTUNED Default PPTestTune
	SAVERUNTUNED DefRope PPTestTune
	SAVERUNTUNED NewSinF PPTestTune
	SAVERUNTUNED NewSinS PPTestTune
	SAVERUNTUNED NoSwing PPTestTune
	SAVERUNTUNED NewSing PPTestTune
	SAVERUNTUNED EffPRel PPTestTune
	SAVERUNTUNED DefaY7F PPTestTune
	SAVERUNTUNED Def01Y7 PPTestTune
	SAVERUNTUNED DefEven PPTestTune
	SAVERUNTUNED DefSwL4 PPTestTune
	SAVERUNTUNED DefSw01 PPTestTune
	SAVERUNTUNED DefFSGO PPTestTune
	SAVERUNTUNED DefFSG2 PPTestTune
	SAVERUNTUNED Shadows PPTestTune
	SAVERUNTUNED DefSing PPTestTune
	SAVERUNTUNED DefComp PPTestTune
	SAVERUNTUNED Shadow8 PPTestTune
	SAVERUNTUNED Shadow9 PPTestTune
	SAVERUNTUNED ShadowA PPTestTune
	SAVERUNTUNED ShadowD PPTestTune
	SAVERUNTUNED ShadowE PPTestTune
	SAVERUNTUNED ShadowF PPTestTune
	SAVERUNTUNED ShadowG PPTestTune
	SAVERUNTUNED ShadowH PPTestTune
	SAVERUNTUNED ShadowI PPTestTune
	SAVERUNTUNED Defaupt PPTestTune

	##### playground #####
	erase PPTestTune:DefaultObjects[0]
	set PPTestTune:DefaultObjects[0] Default

	set PPEventHandler:LambdaQCD 0.22
	set PPEventHandler:RMax 3.0
	set stdEmitter:PMinusOrdering 1.0
	set stdEmitter:PTScale 1.0

	set PPGenerator:EventHandler:PreSamples 0
	# set PPGenerator:EventHandler:PreSamples 0
	set PPGenerator:EventHandler:EventFiller:DebugHist 1
	set PPTestTune:NumberOfEvents 10000

	saverun compare PPTestTune
	set stdEmitter:PMinusOrdering 2.0
	saverun compar5 PPTestTune
	set stdEmitter:PMinusOrdering 1.0
	set PPEventHandler:FudgeME 2
	set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	set PPTestTune:EventHandler:EventFiller:SingleMother 1
	saverun compar2 PPTestTune
	set PPTestTune:EventHandler:EventFiller:CompatMode 1
	saverun compar3 PPTestTune
	set PPTestTune:EventHandler:EventFiller:CompatMode 0
	set PPTestTune:EventHandler:EffectivePartonMode Relatives
	saverun compar4 PPTestTune
	set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	set PPEventHandler:FudgeME 1
	set PPTestTune:EventHandler:EventFiller:SingleMother 0
	set PPTestTune:EventHandler:EventFiller:CompatMode 0


	set PPTestTune:EventHandler:EffectivePartonMode Shadows
	saverun shadows PPTestTune
	set PPEventHandler:FudgeME 2
	set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	set PPTestTune:EventHandler:EventFiller:SingleMother 1
	saverun shadow2 PPTestTune
	saverun shadow3 PPTestTune
	set stdEmitter:MinusOrderingMode EffectiveParton
	saverun shadow4 PPTestTune
	set stdEmitter:MinusOrderingMode TrueShadow
	saverun shadow6 PPTestTune
	set stdEmitter:MinusOrderingMode OrderedShadow
	saverun shadow7 PPTestTune
	set stdXSec:IntOrdering ShadowOpen
	saverun shadow8 PPTestTune
	set stdXSec:IntOrdering ShadowColour
	set PPTestTune:NumberOfEvents 10000
	saverun shadow9 PPTestTune
	set PPTestTune:EventHandler:EventFiller:PTCut 2.0
	set FSOrdering:PTMin 2.0
	saverun shadow11 PPTestTune
	set PPTestTune:EventHandler:EventFiller:PTCut 4.0
	set FSOrdering:PTMin 4.0
	saverun shadow12 PPTestTune
	set PPTestTune:EventHandler:EventFiller:PTCut 1.0
	set FSOrdering:PTMin 1.0
	set stdEmitter:MinusOrderingMode UnorderedShadow
	saverun shadow14 PPTestTune
	set stdXSec:IntOrdering ShadowColourMax
	saverun shadow15 PPTestTune
	saverun shadow16 PPTestTune
	saverun shadow17 PPTestTune
	set stdEmitter:PlusInflation 2.0
	saverun shadow18 PPTestTune
	set stdEmitter:PlusInflation 1.0
	set stdEmitter:MinusOrderingMode CutShadow
	# erase PPTestTune:AnalysisHandlers[0]
	# erase PPTestTune:AnalysisHandlers[0]
	# erase PPTestTune:AnalysisHandlers[0]
	# set PPTestTune:EventHandler:CascadeHandler NULL
	# set PPTestTune:EventHandler:HadronizationHandler NULL
	# set PPTestTune:EventHandler:DecayHandler NULL
	# erase PPTestTune:DefaultObjects[0]
	saverun shadow21 PPTestTune
	set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	saverun shadow23 PPTestTune
	set stdEmitter:SizeFactor 1.0
	saverun shadow30 PPTestTune
	set stdEmitter:SizeFactor 2.0
	set stdEmitter:MinusOrderingMode HalfShadow
	saverun shadow32 PPTestTune
	set stdEmitter:MinusOrderingMode CutShadow

	set stdXSec:KTPow 2.0
	set stdXSec:KT0 1.0
	saverun shadow29 PPTestTune
	set stdEmitter:SizeFactor 1.0
	saverun shadow31 PPTestTune
	set stdEmitter:SizeFactor 2.0
	set stdXSec:KTPow 0.0
	set stdEmitter:PMinusOrdering 2.0
	saverun shadow25 PPTestTune
	set stdEmitter:PMinusOrdering 1.0
	set stdEmitter:PTScale 2.0
	saverun shadow26 PPTestTune
	set stdXSec:PTScale 1
	saverun shadow28 PPTestTune
	set stdXSec:PTScale 0
	set stdXSec:SinFunction Scaled
	saverun shadow27 PPTestTune
	set stdEmitter:PTScale 1.0
	set stdXSec:SinFunction Exact
	set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	set PPTestTune:EventHandler:EffectivePartonMode NewShadows
	saverun shadow22 PPTestTune
	set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	saverun shadow24 PPTestTune
	set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	set PPTestTune:EventHandler:EffectivePartonMode Shadows
	+saverun shadow23 PPTestTune
	+set stdEmitter:PTScale 2
	+saverun shadow24 PPTestTune
	+set PPTestTune:EventHandler:PTScale -1
	+saverun shadow25 PPTestTune
	+set stdEmitter:MinusOrderingMode PtGen
	+saverun shadow26 PPTestTune
	+set stdEmitter:MinusOrderingMode CutShadow
	+set PPTestTune:EventHandler:PTScale 2
	+set stdEmitter:PTScale 1
	+

	set stdXSec:IntOrdering ShadowColour
	set stdEmitter:MinusOrderingMode OrderedShadow
	set PPTestTune:NumberOfEvents 2
	set PPGenerator:EventHandler:PreSamples 10000
	saverun shadow10 PPTestTune
	set stdEmitter:MinusOrderingMode UnorderedShadow
	saverun shadow13 PPTestTune
	set stdXSec:IntOrdering ShadowColourMax
	saverun shadow19 PPTestTune
	set stdEmitter:PlusInflation 10.0
	saverun shadow20 PPTestTune
	set stdEmitter:PlusInflation 1.0
	set stdEmitter:MinusOrderingMode OrderedShadow

	set PPGenerator:EventHandler:PreSamples 0
	set PPTestTune:NumberOfEvents 10000
	set stdXSec:IntOrdering VeryOpen
	set stdEmitter:MinusOrderingMode EffectivePT
	saverun shadow5 PPTestTune
	set PPEventHandler:FudgeME 1
	set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	set PPTestTune:EventHandler:EventFiller:SingleMother 0
	set PPTestTune:EventHandler:EffectivePartonMode Colours

	set PPTestTune:EventHandler:EventFiller:Mode NewSingle
	saverun compsng PPTestTune
	set PPEventHandler:FudgeME 2
	set PPTestTune:EventHandler:EventFiller:OnlyOnce true
	set PPTestTune:EventHandler:EventFiller:SingleMother 1
	saverun compsn2 PPTestTune
	set PPTestTune:EventHandler:EventFiller:CompatMode 1
	saverun compsn3 PPTestTune
	set PPEventHandler:FudgeME 1
	set PPTestTune:EventHandler:EventFiller:OnlyOnce false
	set PPTestTune:EventHandler:EventFiller:SingleMother 0
	set PPTestTune:EventHandler:EventFiller:CompatMode 0

File Metadata

Mime Type: text/x-diff
Expires: Sat, Dec 21, 4:23 PM (21 h, 37 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4023433
Default Alt Text: (71 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions