No OneTemporary
Actions

Size

63 KB

Subscribers

None

View Options

	diff --git a/Decay/EvtGen/EvtGenInterface.cc b/Decay/EvtGen/EvtGenInterface.cc
	--- a/Decay/EvtGen/EvtGenInterface.cc
	+++ b/Decay/EvtGen/EvtGenInterface.cc
	@@ -1,1020 +1,1020 @@
	// -- C++ --
	//
	// This is the implementation of the non-inlined, non-templated member
	// functions of the EvtGenInterface class.
	//

	#include "EvtGenInterface.h"
	#include "ThePEG/Interface/ClassDocumentation.h"
	#include "ThePEG/Interface/Switch.h"
	#include "ThePEG/Interface/Parameter.h"
	#include "ThePEG/Interface/ParVector.h"
	#include "ThePEG/EventRecord/Particle.h"
	#include "ThePEG/Repository/UseRandom.h"
	#include "ThePEG/Repository/EventGenerator.h"
	#include "ThePEG/Utilities/DescribeClass.h"
	#include "ThePEG/Persistency/PersistentOStream.h"
	#include "ThePEG/Persistency/PersistentIStream.h"
	#include "ThePEG/PDT/DecayMode.h"
	#include "Herwig/Decay/DecayVertex.h"
	#include "Herwig/Decay/GeneralDecayMatrixElement.h"

	#include "EvtGenBase/EvtRandom.hh"
	#include "EvtGenBase/EvtAbsRadCorr.hh"
	#include "EvtGenExternal/EvtExternalGenList.hh"
	#include "EvtGenBase/EvtScalarParticle.hh"
	#include "EvtGenBase/EvtDiracParticle.hh"
	#include "EvtGenBase/EvtVectorParticle.hh"
	#include "EvtGenBase/EvtRaritaSchwingerParticle.hh"
	#include "EvtGenBase/EvtTensorParticle.hh"
	#include "EvtGenBase/EvtStringParticle.hh"
	#include "EvtGenBase/EvtHighSpinParticle.hh"
	#include "EvtGenBase/EvtDecayTable.hh"

	-#ifndef EVTGEN_PREFIX
	-#error Makefile.am needs to define EVTGEN_PREFIX
	+#ifndef EVTGEN_SHARE
	+#error Makefile.am needs to define EVTGEN_SHARE
	#endif

	using namespace Herwig;

	namespace {

	-const string prefix=EVTGEN_PREFIX "";
	+const string prefix=EVTGEN_SHARE "";
	const string p8data=PYTHIA8DATA "";

	}

	-EvtGenInterface::EvtGenInterface() : decayName_(prefix+"/share/DECAY_2010.DEC"),
	- pdtName_(prefix+"/share/evt.pdl"),
	+EvtGenInterface::EvtGenInterface() : decayName_(prefix+"/DECAY_2010.DEC"),
	+ pdtName_(prefix+"/evt.pdl"),
	reDirect_(true), checkConv_(false),
	p8Data_(p8data)
	{}

	EvtGenInterface::EvtGenInterface(const EvtGenInterface & x)
	: Interfaced(x), decayName_(x.decayName_), pdtName_(x.pdtName_),
	userDecays_(x.userDecays_), reDirect_(x.reDirect_),
	checkConv_(x.checkConv_), convID_(x.convID_),
	p8Data_(x.p8Data_), evtrnd_(x.evtrnd_),evtgen_(x.evtgen_)
	{}

	EvtGenInterface::~EvtGenInterface() {}

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

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

	void EvtGenInterface::persistentOutput(PersistentOStream & os) const {
	os << decayName_ << pdtName_ << reDirect_
	<< userDecays_ << checkConv_ << convID_ << p8Data_;
	}

	void EvtGenInterface::persistentInput(PersistentIStream & is, int) {
	is >> decayName_ >> pdtName_ >> reDirect_
	>> userDecays_ >> checkConv_ >> convID_ >> p8Data_;
	}


	// The following static variable is needed for the type
	// description system in ThePEG.
	DescribeClass<EvtGenInterface,Interfaced>
	describeHerwigEvtGenInterface("Herwig::EvtGenInterface",
	"HwEvtGenInterface.so");

	void EvtGenInterface::Init() {

	static ClassDocumentation<EvtGenInterface> documentation
	("The EvtGenInterface class is the main class for the use of the EvtGen "
	"decay package with Herwig");

	static Parameter<EvtGenInterface,string> interfaceDecay_File
	("Decay_File",
	"The name of the file for the EvtGen decays.",
	&EvtGenInterface::decayName_, prefix+"/share/DECAY_2010.DEC",
	false, false);

	static Parameter<EvtGenInterface,string> interfacePDT_File
	("PDTFile",
	"The name of the file for the EvtGen particle data.",
	&EvtGenInterface::pdtName_, prefix+"/share/evt.pdl",
	false, false);

	static Switch<EvtGenInterface,bool> interfaceRedirect
	("Redirect",
	"By default cerr and cout are redirected when EvtGen is running to"
	" allow us to catch errors, due to EvtGen's poor internal error "
	"handling. This can be a problem for debugging and so can be switched off.",
	&EvtGenInterface::reDirect_, true, false, false);
	static SwitchOption interfaceRedirectYes
	(interfaceRedirect,
	"Yes",
	"Redirect the output",
	true);
	static SwitchOption interfaceRedirectNo
	(interfaceRedirect,
	"No",
	"Don't redirect the output",
	false);

	static Switch<EvtGenInterface,bool> interfaceCheckConversion
	("CheckConversion",
	"Check the conversion of particles to and from EvtGen",
	&EvtGenInterface::checkConv_, false, false, false);
	static SwitchOption interfaceCheckConversionfalse
	(interfaceCheckConversion,
	"No",
	"Don't check the conversion",
	false);
	static SwitchOption interfaceCheckConversionCheck
	(interfaceCheckConversion,
	"Yes",
	"Check the conversion",
	true);

	static ParVector<EvtGenInterface,long> interfaceOutputModes
	("OutputModes",
	"Particles for which to output the EvtGen decay modes"
	" so they can be read into Herwig",
	&EvtGenInterface::convID_, -1, long(0), 0, 0,
	false, false, Interface::nolimits);

	static ParVector<EvtGenInterface,string> interfaceUserDecays
	("UserDecays",
	"List of user decay files to be loaded",
	&EvtGenInterface::userDecays_, -1, "", "", "",
	false, false, Interface::nolimits);

	static Parameter<EvtGenInterface,string> interfacePythia8Data
	("Pythia8Data",
	"Location of the Pythia8 data directory",
	&EvtGenInterface::p8Data_, p8data,
	false, false);

	}

	void EvtGenInterface::doinitrun() {
	Interfaced::doinitrun();
	// redirect cerr and cout if needed
	std::streambuf *temp[2]={cout.rdbuf(),cerr.rdbuf()};
	if(reDirect_ && ! generator()->useStdOut() ) {
	const string f = generator()->filename() + "-EvtGen.log";
	logFile_.open(f);
	std::streambuf *psbuf = logFile_.rdbuf();
	cout.rdbuf(psbuf);
	cerr.rdbuf(psbuf);
	}
	// output the EvtGen initialization info to the log file
	cout << "Initializing EvtGen \n";
	// set up the random number generator for EvtGen
	cout << "Setting EvtGen random number generator"
	<< " to the Herwig one.\n";
	evtrnd_ = new EvtGenRandom(const_ptr_cast<Ptr<RandomGenerator>::pointer>
	(&(UseRandom::current())));
	EvtRandom::setRandomEngine(evtrnd_);
	// PHOTOS STUFF
	EvtAbsRadCorr* radCorrEngine = 0;
	std::list<EvtDecayBase*> extraModels;
	EvtExternalGenList genList(true,p8Data_,"gamma",true);
	radCorrEngine = genList.getPhotosModel();
	extraModels = genList.getListOfModels();
	// Initialize EvtGen
	evtgen_ = new EvtGen(decayName_.c_str(),pdtName_.c_str(),
	evtrnd_, radCorrEngine, &extraModels);
	// additional user decays
	for(unsigned int ix=0;ix<userDecays_.size();++ix)
	evtgen_->readUDecay(userDecays_[ix].c_str());
	// check the conversion of particles if needed
	if(checkConv_) checkConversion();
	// convert any particle decay modes which are needed
	for(unsigned int ix=0;ix<convID_.size();++ix) {
	outputEvtGenDecays(convID_[ix]);
	}
	// that's the lot
	cout << "Finished initialisation of EvtGen \n";
	if(reDirect_ && ! generator()->useStdOut() ) {
	cout.rdbuf(temp[0]);
	cerr.rdbuf(temp[1]);
	}
	}

	void EvtGenInterface::dofinish() {
	Interfaced::dofinish();
	if(logFile_.is_open())
	logFile_.close();
	}

	ParticleVector EvtGenInterface::decay(const Particle &parent,
	bool recursive, const DecayMode & dm) const {
	// redirect cout to the log file
	ostringstream stemp;
	std::streambuf *temp[2]={cout.rdbuf(),cerr.rdbuf()};
	if(reDirect_ && ! generator()->useStdOut() ) {
	std::streambuf *psbuf[2] ={logFile_.rdbuf(),stemp.rdbuf()};
	cout.rdbuf(psbuf[0]);
	cerr.rdbuf(psbuf[1]);
	}
	// generate the decay
	ParticleVector output;
	EvtId parID(EvtGenID(parent.id()));
	try {
	EvtDecayBase *decayer = NULL;
	// create evtgen particle for the parent
	EvtParticle* particle = EvtGenParticle(parent);
	EvtParticle* evtParent = NULL;
	// special if parent is the same to avoid doing mixing twice
	if(parent.parents().size()==1 && abs(parent.parents()[0]->id())==abs(parent.id())) {
	evtParent = EvtGenParticle(*parent.parents()[0]);
	particle->addDaug(evtParent);
	}
	// simplest case, evtgen selects mode and recursively decays, use their standard mechanism
	if(dm.wildProductMatcher() && recursive) {
	evtgen_->generateDecay(particle);
	}
	// otherwise we're in control
	else {
	// select the EvtGen decayer to use
	if(dm.wildProductMatcher()) {
	decayer = EvtDecayTable::getInstance()->getDecayFunc(particle);
	}
	// otherwise we should pick one
	else {
	int imode(EvtGenChannel(dm));
	decayer = EvtDecayTable::getInstance()->getDecay(parID.getAlias(),imode);
	particle->setChannel(imode);
	}
	// must be a decayer
	if(!decayer) throw Exception() << "Could find EvtGen decayer in EvtGen::decay()"
	<< Exception::runerror;
	// masses of the children
	bool massTreeOK(true);
	if ( particle->getNDaug() == 0 )
	massTreeOK = particle->generateMassTree();
	if ( ! massTreeOK ) {
	// delete the EvtGen particle
	particle->deleteDaughters();
	delete particle;
	particle = 0;
	if(evtParent) {
	delete evtParent;
	}
	throw Exception() << "EvtGen could not decay " << EvtPDL::name(particle->getId())
	<<" with mass "<< particle->mass()
	<<" to decay channel number "<< particle->getChannel() << "\n"
	<< Exception::eventerror;
	}
	assert(decayer !=0 );
	// perform decay
	decayer->makeDecay(particle,recursive);
	}
	// cast the decayer
	EvtDecayAmp damp = dynamic_cast<EvtDecayAmp>(decayer);
	// translate the decay products
	output=decayProducts(particle);
	// set spin information if needed
	tSpinPtr pspin(getSpinInfo(parent));
	// if has spin information translate it
	if(damp) {
	ParticleVector products;
	unsigned int nbeforerad=decayer->getNDaug();
	for(unsigned int ix=0;ix<nbeforerad;++ix) products.push_back(output[ix]);
	constructVertex(parent,products,damp);
	}
	// otherwise
	else {
	pspin->develop();
	RhoDMatrix rhotemp(pspin->iSpin());
	pspin->DMatrix()=rhotemp;
	}
	pspin->decay();
	if(recursive) {
	pspin->developed();
	pspin->DMatrix()=ThePEGSpinDensity(particle->getSpinDensityBackward(),
	ThePEGID(particle->getId()));
	}
	// delete the EvtGen particle
	particle->deleteDaughters();
	delete particle;
	if(evtParent) {
	delete evtParent;
	}
	particle = 0;
	}
	catch ( ... ) {
	// change stream back
	if(reDirect_ && ! generator()->useStdOut() ) {
	cout.rdbuf(temp[0]);
	cerr.rdbuf(temp[1]);
	}
	throw;
	}
	// change stream back
	if(reDirect_ && ! generator()->useStdOut() ) {
	cout.rdbuf(temp[0]);
	cerr.rdbuf(temp[1]);
	string stemp2=stemp.str();
	if(stemp2.length()>0)
	throw Exception() << "EvtGen report error in EvtGen::decay "
	<< "killing event\n"
	<< "Error was " << stemp2
	<< Exception::eventerror;
	}
	// return the decay products
	return output;
	}

	EvtParticle * EvtGenInterface::EvtGenParticle(const Particle & part) const {
	// convert the momentum
	Lorentz5Momentum inmom(part.momentum());
	EvtVector4R p4(EvtGenMomentum(inmom));
	EvtParticle *evtpart;
	// EvtGen ID and spin type
	EvtId id = EvtGenID(part.id());
	EvtSpinType::spintype thisSpin=EvtPDL::getSpinType(id);
	// boost to the rest frame to get the basis states right
	PPtr decay(const_ptr_cast<PPtr>(new_ptr(part)));
	decay->transform(LorentzRotation(-inmom.boostVector()));
	// get spin information so can transfer to EvtGen
	tcSpinPtr spin(dynamic_ptr_cast<tcSpinPtr>(part.spinInfo()));
	if(spin) spin->decay();
	// don't convert neutrinos, aren't decays so waste of time
	if ( thisSpin == EvtSpinType::NEUTRINO) {
	throw Exception() << "Tried to convert a neutrino to EvtGen in "
	<< "EvtGen::EvtParticle. This should not be needed as"
	<< "EvtGen does not decay neutrinos"
	<< Exception::eventerror;
	}
	// don't convert photons, aren't decays so waste of time
	else if ( thisSpin == EvtSpinType::PHOTON ) {
	throw Exception() << "Tried to convert a photon to EvtGen in "
	<< "EvtGen::EvtParticle. This should not be needed as"
	<< "EvtGen does not decay photons"
	<< Exception::eventerror;
	}
	// scalar particles
	else if ( thisSpin == EvtSpinType::SCALAR ) {
	// create particle
	EvtScalarParticle * myPart = new EvtScalarParticle;
	myPart->init(id, p4);
	// set rho matrix if needed
	tcScalarSpinPtr sp(dynamic_ptr_cast<tcScalarSpinPtr>(spin));
	if(sp) {
	myPart->setSpinDensityForward(EvtGenSpinDensity(sp->rhoMatrix()));
	}
	else {
	EvtSpinDensity rho;
	rho.setDiag(EvtSpinType::getSpinStates(thisSpin));
	myPart->setSpinDensityForward(rho);
	}
	evtpart=myPart;
	}
	else if ( thisSpin == EvtSpinType::DIRAC ) {
	EvtDiracParticle *myPart =new EvtDiracParticle;
	// get the spin info
	tcFermionSpinPtr sp(dynamic_ptr_cast<tcFermionSpinPtr>(spin));
	// has spin info transfer
	if(sp) {
	vector<EvtDiracSpinor> prod,decay;
	// transfer spinors
	for(unsigned int ix=0;ix<2;++ix) {
	prod .push_back(EvtGenSpinor(sp->getProductionBasisState(ix)));
	decay.push_back(EvtGenSpinor(sp->getDecayBasisState (ix)));
	}
	myPart->init(id, p4,prod[0],prod[1],decay[0],decay[1]);
	// set the density matrix
	myPart->setSpinDensityForward(EvtGenSpinDensity(sp->rhoMatrix()));
	}
	// no spin info
	else {
	myPart->init(id, p4);
	EvtSpinDensity rho;
	rho.setDiag(EvtSpinType::getSpinStates(thisSpin));
	myPart->setSpinDensityForward(rho);
	}
	evtpart=myPart;
	}
	// vector particles
	else if ( thisSpin == EvtSpinType::VECTOR ) {
	EvtVectorParticle *myPart=new EvtVectorParticle;
	// get the spin info
	tcVectorSpinPtr sp(dynamic_ptr_cast<tcVectorSpinPtr>(spin));
	// has spin info transfer
	if(sp) {
	// transfer polarization vectors
	vector<EvtVector4C> eps;
	for(unsigned int ix=0;ix<3;++ix) {
	eps.push_back(EvtGenPolarization(sp->getDecayBasisState(ix)));
	}
	myPart->init(id, p4,eps[0],eps[1],eps[2]);
	// set spin density matrix
	myPart->setSpinDensityForward(EvtGenSpinDensity(sp->rhoMatrix()));
	}
	// no spin info
	else {
	myPart->init(id, p4);
	EvtSpinDensity rho;
	rho.setDiag(EvtSpinType::getSpinStates(thisSpin));
	myPart->setSpinDensityForward(rho);
	}
	evtpart=myPart;
	}
	// spin 3/2 particles
	else if ( thisSpin == EvtSpinType::RARITASCHWINGER ) {
	EvtRaritaSchwingerParticle *myPart=new EvtRaritaSchwingerParticle;
	// get the spin info
	tcRSFermionSpinPtr sp(dynamic_ptr_cast<tcRSFermionSpinPtr>(spin));
	// has spin info transfer
	if(sp) {
	// transfer spinors
	vector<EvtRaritaSchwinger> prod,decay;
	for(unsigned int ix=0;ix<4;++ix) {
	prod .push_back(EvtGenRSSpinor(sp->getProductionBasisState(ix)));
	decay.push_back(EvtGenRSSpinor(sp->getDecayBasisState(ix) ));
	}
	myPart->init(id, p4,
	prod[0] ,prod[1] ,prod[2] , prod[3],
	decay[0],decay[1],decay[2],decay[3]);
	// set spin density matrix
	myPart->setSpinDensityForward(EvtGenSpinDensity(sp->rhoMatrix()));
	}
	// no spin info
	else {
	myPart->init(id, p4);
	EvtSpinDensity rho;
	rho.setDiag(EvtSpinType::getSpinStates(thisSpin));
	myPart->setSpinDensityForward(rho);
	}
	evtpart=myPart;
	}
	// spin-2 particles
	else if ( thisSpin == EvtSpinType::TENSOR ) {
	EvtTensorParticle *myPart =new EvtTensorParticle;
	tcTensorSpinPtr sp(dynamic_ptr_cast<tcTensorSpinPtr>(spin));
	// has spin info transfer
	if(sp) {
	// transfer the polarization tensors
	vector<EvtTensor4C> eps;
	for(unsigned int ix=0;ix<5;++ix) {
	eps.push_back(EvtGenTensor(sp->getDecayBasisState(ix)));
	}
	myPart->init(id, p4,eps[0],eps[1],eps[2],eps[3],eps[4]);
	// set spin density matrix
	myPart->setSpinDensityForward(EvtGenSpinDensity(sp->rhoMatrix()));
	}
	// no spin info
	else {
	myPart->init(id, p4);
	EvtSpinDensity rho;
	rho.setDiag(EvtSpinType::getSpinStates(thisSpin));
	myPart->setSpinDensityForward(rho);
	}
	evtpart=myPart;
	}
	// shouldn't be doing this but here for safety
	else if ( thisSpin == EvtSpinType::STRING ) {
	EvtStringParticle *myPart;
	myPart=new EvtStringParticle;
	myPart->init(id, p4);
	EvtSpinDensity rho;
	rho.setDiag(EvtSpinType::getSpinStates(thisSpin));
	myPart->setSpinDensityForward(rho);
	evtpart=myPart;
	}
	// high spin particles
	else if ( thisSpin == EvtSpinType::SPIN3 \|\| thisSpin == EvtSpinType::SPIN5HALF \|\|
	thisSpin == EvtSpinType::SPIN4 \|\| thisSpin == EvtSpinType::SPIN7HALF) {
	EvtHighSpinParticle *myPart;
	myPart=new EvtHighSpinParticle;
	myPart->init(id, p4);
	EvtSpinDensity rho;
	rho.setDiag(EvtSpinType::getSpinStates(thisSpin));
	myPart->setSpinDensityForward(rho);
	evtpart=myPart;
	}
	else {
	throw Exception() << "Can't convert particle to EvtGen "
	<< part << Exception::eventerror;
	}
	// boost particle back and return the particle
	decay->boost(inmom.boostVector());
	return evtpart;
	}

	// convert from ThePEG to EvtGen
	EvtId EvtGenInterface::EvtGenID(int id, bool exception) const {
	EvtId output;
	int absid=abs(id),ispin(absid%10),isgn(id/absid);
	// handle the easy cases
	if(
	//quarks(+excited)
	absid<=8\|\|
	// leptons(+exicted)
	(absid>=11&&absid<=18)\|\|
	// SM(+extensions) gauge bosons and higgs
	(absid>=21&&absid<=25)\|\|(absid>=32&&absid<=37)\|\|
	// 1 1S0, 1 3S1 and 1 3P2 1 3D3 mesons are the same
	(absid>100&&absid<600&&ispin%2==1&&ispin<=9)\|\|
	// 2 1S0, 2 3S1 are the same
	(absid>100100&&absid<100600&&(ispin==1\|\|ispin==3))\|\|
	// 1 3d1 goes to 3s in evtgen
	(absid>30100&&absid<30600&&ispin==3) \|\|
	// 1 1P1 mesons are the same apart from D_s1
	(absid>10100&&absid<10600&&(ispin==3)) \|\|
	// 1 3P1 mesons are the same apart from D_s1
	(absid>20100&&absid<20600&&(ispin==3)) \|\|
	// mixed kaons and diffractive states
	(absid>=100&&absid<=3000&&ispin==0)) {
	output = EvtPDL::evtIdFromStdHep(id);
	}
	// lowest baryon multiplets and diquarks are almost the same
	else if(absid>1000&&absid<6000&&ispin>=1&&ispin<=4) {
	output = EvtPDL::evtIdFromStdHep(id);
	}
	// 1 3p0 same apart from f'0
	else if (absid>10100&&absid<10600&&ispin==1) {
	if(absid==10221) output = EvtPDL::evtIdFromStdHep(isgn*30221);
	else output = EvtPDL::evtIdFromStdHep(id);
	}
	// excited baryons
	else if(((absid>10000&&absid<16000)\|\|(absid>20000&&absid<26000)\|\|
	(absid>30000&&absid<36000))&&(ispin==2\|\|ispin==4)) {
	output=EvtPDL::evtIdFromStdHep(id);
	}
	// special for any bottomonium states
	else if((absid%1000)/10==55) {
	output=EvtPDL::evtIdFromStdHep(id);
	}
	// special meson codes
	else if (absid>9000000) {
	// f_0/a_0(980) goes into f_0/a_0(980)
	if(absid==9000111\|\|absid==9000211\|\|absid==9010221) {
	output=EvtPDL::evtIdFromStdHep(id);
	}
	// sigma
	else if(absid==9000221) {
	output=EvtPDL::evtIdFromStdHep(id);
	}
	// psi(4040)
	else if(absid==9000443) {
	output=EvtPDL::evtIdFromStdHep(50443);
	}
	// f_0(1500)
	else if(absid==9030221) {
	output=EvtPDL::evtIdFromStdHep(9020221);
	}
	}
	// check its O.K.
	if(output.getAlias()==-1&&exception) {
	throw Exception() << "Can't find the EvtGen Id for particle "
	<< getParticleData(id)->PDGName()
	<< " with PDG code = "
	<< id << " in EvtGen::EvtGenID"
	<< Exception::eventerror;
	}
	return output;
	}

	ParticleVector EvtGenInterface::decayProducts(EvtParticle *part, bool boost) const {
	ParticleVector output,temp;
	for(unsigned int ix=0,N=part->getNDaug();ix<N;++ix) {
	// get the daughter particle
	EvtParticle * daug = part->getDaug(ix);
	// may just have been used for mass generation, so check has valid momentum
	if(!daug->hasValidP4()) continue;
	// get the Herwig ParticleData object
	int id=ThePEGID(daug->getId());
	tcPDPtr pd=getParticleData(id);
	// if easy to convert do it
	if(pd) output.push_back(ThePEGParticle(daug,pd));
	// special for EvtGen particles like string we don't need to include
	else if(id==90) {
	// check if needs to be decayed by EvtGen
	if(EvtPDL::getStdHep(daug->getId())==92\|\|daug->isDecayed()) {
	// add the particles
	ParticleVector temp(decayProducts(daug,EvtPDL::getStdHep(daug->getId())!=92));
	if(EvtPDL::getStdHep(daug->getId())==92) {
	Lorentz5Momentum pstring(ThePEGMomentum(daug->getP4(),daug->mass()));
	Boost bv(-pstring.x()/pstring.e(),-pstring.y()/pstring.e(),-pstring.z()/pstring.e());
	for(unsigned int ix=0;ix<temp.size();++ix) {
	temp[ix]->deepBoost(bv);
	}
	}
	for(unsigned int iy=0;iy<temp.size();++iy) output.push_back(temp[iy]);
	}
	else if(!daug->isDecayed()) {
	EvtDecayBase *decayer = EvtDecayTable::getInstance()->getDecayFunc(daug);
	// must be a decayer
	if(!decayer) throw Exception() << "Could find EvtGen decayer in "
	<< "EvtGenInterface::decayProducts()"
	<< Exception::runerror;
	// If there are already daughters, then this step is already done!
	// figure out the masses
	if ( daug->getNDaug() == 0 ) daug->generateMassTree();
	// perform decay
	decayer->makeDecay(daug,false);
	// add the particles
	ParticleVector temp(decayProducts(daug));
	for(unsigned int iy=0;iy<temp.size();++iy) output.push_back(temp[iy]);
	}
	}
	else {
	throw Exception() << "Tried to convert an unknown particle, PDG code = " << id
	<< " from EvtGen in EvtGen::decayproducts which is "
	<< " unknown to Herwig. Killing event."
	<< Exception::eventerror;
	}
	}
	// boost to lab
	if(output.size()>0) {
	if(boost) {
	Boost bv=ThePEGMomentum(part->getP4(),part->mass()).boostVector();
	for(unsigned int ix=0; ix<output.size(); ++ix) output[ix]->deepBoost(bv);
	}
	}
	return output;
	}

	void EvtGenInterface::ThePEGSpin(PPtr peg,EvtParticle *evt) const {
	// if no corresponding ThePEG spin type return
	if(evt->getSpinType()==EvtSpinType::STRING\|\|
	evt->getSpinType()==EvtSpinType::SPIN3\|\|evt->getSpinType()==EvtSpinType::SPIN4\|\|
	evt->getSpinType()==EvtSpinType::SPIN5HALF\|\|
	evt->getSpinType()==EvtSpinType::SPIN7HALF) return;
	// now deal with the other cases
	// scalars
	unsigned int ix;
	SpinPtr spin;
	if(evt->getSpinType()==EvtSpinType::SCALAR) {
	ScalarSpinPtr sca(new_ptr(ScalarSpinInfo(peg->momentum(),true)));
	spin=sca;
	}
	// massless spin 1/2
	else if(evt->getSpinType()==EvtSpinType::NEUTRINO) {
	FermionSpinPtr fer(new_ptr(FermionSpinInfo(peg->momentum(),true)));
	spin=fer;
	ix=peg->id()<0;
	fer->setBasisState(ix,ThePEGSpinor(evt->spParentNeutrino()));
	ix=peg->id()>0;
	fer->setBasisState(ix,LorentzSpinor<SqrtEnergy>());
	}
	// massive spin-1/2
	else if(evt->getSpinType()==EvtSpinType::DIRAC) {
	FermionSpinPtr fer(new_ptr(FermionSpinInfo(peg->momentum(),true)));
	spin=fer;
	for(ix=0;ix<2;++ix) {
	fer->setBasisState(ix,ThePEGSpinor(evt->spParent(ix)));
	}
	}
	// massless vectors
	else if(evt->getSpinType()==EvtSpinType::PHOTON) {
	VectorSpinPtr vec(new_ptr(VectorSpinInfo(peg->momentum(),true)));
	spin=vec;
	for(ix=0;ix<1;++ix) {
	vec->setBasisState(2*ix,ThePEGPolarization(evt->epsParentPhoton(ix)));}
	vec->setBasisState(1,LorentzVector<Complex>());
	}
	// massive vectors
	else if(evt->getSpinType()==EvtSpinType::VECTOR) {
	VectorSpinPtr vec(new_ptr(VectorSpinInfo(peg->momentum(),true)));
	spin=vec;
	for(ix=0;ix<3;++ix) {
	vec->setBasisState(ix,ThePEGPolarization(evt->epsParent(ix)));
	}
	}
	// massive spin 3/2
	else if(evt->getSpinType()==EvtSpinType::RARITASCHWINGER) {
	RSFermionSpinPtr rs(new_ptr(RSFermionSpinInfo(peg->momentum(),true)));
	spin=rs;
	for(ix=0;ix<4;++ix) {
	rs->setBasisState(ix,ThePEGRSSpinor(evt->spRSParent(ix)));}
	}
	// tensors
	else if(evt->getSpinType()==EvtSpinType::TENSOR) {
	TensorSpinPtr ten(new_ptr(TensorSpinInfo(peg->momentum(),true)));
	spin=ten;
	for(ix=0;ix<5;++ix) {
	ten->setBasisState(ix,ThePEGTensor(evt->epsTensorParent(ix)));
	}
	}
	else {
	throw Exception() << "Unknown EvtGen spin type in EvtGen::ThePEGSpin() "
	<< Exception::runerror;
	}
	// set the spininfo
	peg->spinInfo(spin);
	// final set up if the particle has decayed
	if(evt->getSpinDensityForward().getDim()!=0) {
	spin->rhoMatrix()=ThePEGSpinDensity(evt->getSpinDensityForward(),peg->id());
	}
	if(evt->isDecayed()) {
	spin->decayed(true);
	spin->develop();
	if(evt->getSpinDensityBackward().getDim()!=0) {
	spin->DMatrix()=ThePEGSpinDensity(evt->getSpinDensityBackward(),peg->id());
	}
	}
	}

	// convert from EvtGen to ThePEG
	int EvtGenInterface::ThePEGID(EvtId eid,bool exception) const {
	int output(0);
	int id(EvtPDL::getStdHep(eid)),absid(abs(id)),ispin(absid%10);
	// handle the easy cases
	// special particles like string which we delete and include decay products
	if(absid==92\|\|absid==41\|\|absid==42\|\|absid==43\|\|absid==44\|\|
	absid==30343\|\|absid==30353\|\|
	absid==30363\|\|absid==30373\|\|absid==30383) {
	output=90;
	}
	//quarks(+excited)
	else if(absid<=8\|\|
	// leptons(+excited)
	(absid>=11&&absid<=18)\|\|
	// SM gauge bosons and higgs
	(absid>=21&&absid<=25)\|\|(absid>=32&&absid<=37)\|\|
	// 1 1S0, 1 3S1 and 1 3P2 mesons are the same
	(absid>100&&absid<600&&(ispin%2==1&&ispin<9))\|\|
	// 2 1S0 and 2 3S1 mesons are the same
	(absid>100100&&absid<100600&&(ispin==1\|\|ispin==3))\|\|
	// 1 3p0 are the same
	(absid>10100&&absid<10600&&ispin==1) \|\|
	// 3d1 are the same
	(absid>30100&&absid<30600&&ispin==3) \|\|
	// 1 1P1 mesons are the same
	(absid>10100&&absid<10600&&(ispin==3)) \|\|
	// 1 3P1 mesons are the same
	(absid>20100&&absid<20600&&(ispin==3)) \|\|
	// lowest baryon multiplets and diquarks
	(absid>1000&&absid<6000&&ispin>=1&&ispin<=4)\|\|
	// mixed kaons and diffractive states
	(absid>=100&&absid<=3000&&ispin==0)) {
	output=id;
	}
	// 1 3P0 special for f'0
	else if(absid==30221)
	output = 10221;
	// special for the virtual W (we don't distinguish so return W)
	else if(absid==89) return id/absid*24;
	// excited baryons
	else if(((absid>10000&&absid<16000)\|\|(absid>20000&&absid<26000)\|\|
	(absid>30000&&absid<36000))&&(ispin==2\|\|ispin==4)) {
	output=id;
	}
	// bottomium
	else if((absid%1000)/10==55) {
	output = id;
	}
	// special mesons
	else if(absid>9000000) {
	// f_0/a_0(980) goes into f_0/a_0(980)
	if(absid==9000111\|\|absid==9000211\|\|absid==9010221) {
	output=id;
	}
	// sigma
	else if(absid==9000221) {
	output=id;
	}
	// psi(4040)
	else if(absid==9000443) {
	output=id;
	}
	// f_0(1500)
	else if(absid==9020221) {
	output=9030221;
	}
	}
	// check its O.K.
	if(output==0&&exception) {
	throw Exception() << "Can't find the ThePEG id for particle "
	<< EvtPDL::name(eid)
	<< " with PDG code = "
	<< id << " in EvtGen::ThePEGID"
	<< Exception::eventerror;
	}
	return output;
	}

	RhoDMatrix EvtGenInterface::ThePEGSpinDensity(const EvtSpinDensity & rho, int id) const {
	RhoDMatrix output;
	unsigned int ix,iy;
	// special for neutrinos
	if(abs(id)%2==0&&abs(id)>=12&&abs(id)<=16) {
	output = RhoDMatrix(PDT::Spin1Half, false);
	if(id>0) output(0,0)=ThePEGComplex(rho.get(0,0));
	else output(1,1)=ThePEGComplex(rho.get(0,0));
	}
	// special for photons
	else if(id==ParticleID::gamma) {
	output = RhoDMatrix(PDT::Spin1, false);
	for(ix=0;ix<2;++ix) {
	for(iy=0;iy<2;++iy) output(2ix,2iy)=ThePEGComplex(rho.get(ix,iy));
	}
	}
	// normal behaviour
	else {
	unsigned int ndim(abs(rho.getDim()));
	if(ndim!=0) {
	output = RhoDMatrix(PDT::Spin(ndim));
	for(ix=0;ix<ndim;++ix) {
	for(iy=0;iy<ndim;++iy) output(ix,iy)=ThePEGComplex(rho.get(ix,iy));
	}
	}
	else if(ndim==0) {
	output = RhoDMatrix(PDT::Spin0);
	}
	}
	return output;
	}

	void EvtGenInterface::checkConversion() const {
	// check the translation of particles from ThePEG to EvtGen.
	ParticleMap::const_iterator pit = generator()->particles().begin();
	ParticleMap::const_iterator pend = generator()->particles().end();
	cout << "Testing conversion of particles from ThePEG to EvtGen\n";
	EvtId etemp;
	for(;pit!=pend;++pit) {
	cout << pit->first << " ";
	etemp=EvtGenID(pit->first,false);
	Energy mass = pit->second->mass();
	Energy width = pit->second->width();
	if(etemp.getAlias()>=0) {
	cout << pit->second->PDGName() << "\t becomes "
	<< EvtPDL::name(etemp) << "\t "
	<< EvtPDL::getStdHep(etemp);
	if(ThePEGID(etemp,false)-pit->first!=0) {
	cout << " and converting back to ThePEG fails";
	}
	double mass2 = EvtPDL::getMeanMass(etemp);
	double width2 = EvtPDL::getWidth(etemp);
	if(mass!=ZERO) {
	double delta = (mass-mass2*GeV)/mass;
	if(abs(delta)>1e-6)
	cout << " Mass Difference " << mass/GeV-mass2;
	}
	if(width>ZERO) {
	double delta = (width-width2*GeV)/width;
	if(abs(delta)>1e-6)
	cout << " Width Difference " << width/GeV-width2;
	}
	cout << "\n";
	}
	else {
	cout << pit->second->PDGName()
	<< " has no match in EvtGen \n";
	}
	}
	// test the conversion the other way
	cout << "Testing conversion of particles from EvtGen to ThePEG\n";
	int idtemp;
	tcPDPtr ptemp;
	for(unsigned int ix=0;ix<EvtPDL::entries();++ix) {
	cout << EvtPDL::getStdHep(EvtPDL::getEntry(ix)) << " "
	<< EvtPDL::name(EvtPDL::getEntry(ix));
	idtemp=ThePEGID(EvtPDL::getEntry(ix),false);
	ptemp=getParticleData(idtemp);
	if(ptemp) {
	cout << " becomes " << ptemp->PDGName() << " "
	<< ptemp->id();
	if(EvtGenID(ptemp->id(),false)!=EvtPDL::getEntry(ix)) {
	cout << " and converting back to EvtGEN fails ";
	}
	cout << "\n";
	}
	else {
	cout << " has no match in ThePEG \n";
	}
	}
	}

	void EvtGenInterface::outputEvtGenDecays(long parentid) const {
	// output the decay modes from EvtGen so we can read them in
	EvtId parent(EvtGenID(parentid));
	// get evtids for children
	cout << "Outputting decays for "
	<< getParticleData(parentid)->PDGName() << "\n";
	for(int ix=0;ix<EvtDecayTable::getInstance()->getNMode(parent.getAlias());++ix) {
	EvtDecayBase* decayer=EvtDecayTable::getInstance()->getDecay(parent.getAlias(),ix);
	vector<long> pegid;
	for(int iy=0;iy<decayer->getNDaug();++iy) {
	pegid.push_back(ThePEGID(decayer->getDaug(iy),false));
	}
	for(unsigned int iy=pegid.size();iy<7;++iy) pegid.push_back(0);
	double br=decayer->getBranchingFraction();
	cout
	<< "insert into decay_modes (incomingID,BR,decayon,star,outgoingID1,"
	<< "outgoingID2,outgoingID3,outgoingID4,outgoingID5,outgoingID6,outgoingID7,"
	<< "description,decayer) values (" << parentid << "," << br << ",'on','*',";
	for(int iy=0;iy<7;++iy) {
	cout << pegid[iy] << ",";
	}
	cout << "'Decay of %name% with branching "
	<< "ratio taken from EvtGen.',3);\n";
	}
	}

	int EvtGenInterface::EvtGenChannel(const DecayMode & dm) const {
	// get evtid for parent
	EvtId parent(EvtGenID(dm.parent()->id()));
	// get evtids for children
	EvtId daugs[20];
	unsigned int ndaug(0);
	ParticleMSet::const_iterator pit = dm.products().begin();
	ParticleMSet::const_iterator pend = dm.products().end();
	EvtId etemp;
	for( ;pit!=pend&&ndaug<20;++pit) {
	etemp=EvtGenID((**pit).id());
	daugs[ndaug]=etemp;
	ndaug++;
	}
	if(ndaug>=20) throw Exception() << "Too many decay products "
	<< "in EvtGen::EvtGenChannel"
	<< Exception::eventerror;
	// find the channel
	int output=EvtDecayTable::getInstance()->inChannelList(parent,ndaug,daugs);
	if(output<0) {
	string dmode;
	dmode = "decay of " + dm.parent()->PDGName() + " -> ";
	pit = dm.products().begin();
	pend = dm.products().end();
	for( ;pit!=pend&&ndaug<20;++pit) dmode += (**pit).PDGName()+" ";
	throw Exception() << "Can't find EVtGen decay mode in EvtGenChannel for "
	<< dmode << " in EvtGen::EvtGenChannel"
	<< Exception::runerror;
	}
	return output;
	}

	// translate the matrix element to our form
	void EvtGenInterface::constructVertex(const Particle & parent,
	ParticleVector products,
	EvtDecayAmp* damp) const {
	unsigned int ix,iy;
	vector <PDT::Spin> outspin;
	for(ix=0;ix<products.size();++ix) {
	outspin.push_back(products[ix]->dataPtr()->iSpin());
	}
	vector<int> constants(products.size()+2,0);
	unsigned int nstate(1),idtemp;
	for(ix=outspin.size();ix>0;--ix) {
	idtemp=abs(products[ix-1]->id());
	if(idtemp==ParticleID::gamma) {
	nstate*=2;
	constants[ix]=nstate;
	}
	else if(idtemp%2==0&&idtemp>=12&&idtemp<=16) {
	constants[ix]=nstate;
	}
	else {
	nstate*=outspin[ix-1];
	constants[ix]=nstate;
	}
	}
	PDT::Spin inspin(parent.dataPtr()->iSpin());
	nstate*=inspin;
	constants[0]=nstate;
	constants[outspin.size()+1]=1;
	int eind[10]={0,0,0,0,0,0,0,0,0,0};
	unsigned int iloc;
	vector<unsigned int> hind(outspin.size()+1,0);
	DecayMEPtr newME = new_ptr(GeneralDecayMatrixElement(inspin,outspin));
	for(ix=0;ix<nstate;++ix) {
	iloc=0;
	hind[0]=ix/constants[1];
	if(inspin!=PDT::Spin0) {
	eind[iloc]=hind[0];
	++iloc;
	}
	for(iy=0;iy<outspin.size();++iy) {
	if(outspin[iy]==PDT::Spin0) {
	hind[iy+1]=0;
	}
	else if(products[iy]->id()==ParticleID::gamma) {
	hind[iy+1]=2*(ix%constants[iy+1])/constants[iy+2];
	eind[iloc]=hind[iy+1]/2;
	++iloc;
	}
	else if(constants[iy+1]==1) {
	hind[iy+1]=products[iy]->id()<0;
	}
	else {
	hind[iy+1]=(ix%constants[iy+1])/constants[iy+2];
	eind[iloc]=hind[iy+1];++iloc;
	}
	}
	if(iloc==0) eind[0]=0;
	(*newME)(hind)=ThePEGComplex(damp->amplitude().getAmp(eind));
	}
	// create the decay vertex
	VertexPtr vertex(new_ptr(DecayVertex()));
	DVertexPtr Dvertex(dynamic_ptr_cast<DVertexPtr>(vertex));
	// set the incoming particle for the decay vertex
	dynamic_ptr_cast<tcSpinPtr>(parent.spinInfo())->decayVertex(vertex);
	for(ix=0;ix<products.size();++ix) {
	dynamic_ptr_cast<tcSpinPtr>(products[ix]->spinInfo())
	->productionVertex(vertex);
	}
	// set the matrix element
	Dvertex->ME(newME);
	}
	diff --git a/Decay/EvtGen/Makefile.am b/Decay/EvtGen/Makefile.am
	--- a/Decay/EvtGen/Makefile.am
	+++ b/Decay/EvtGen/Makefile.am
	@@ -1,12 +1,12 @@
	pkglib_LTLIBRARIES = HwEvtGenInterface.la

	HwEvtGenInterface_la_SOURCES = \
	EvtGenInterface.cc EvtGenInterface.h EvtGenInterface.fh \
	EvtGenRandom.h \
	EvtGenDecayer.cc EvtGenDecayer.h

	HwEvtGenInterface_la_LDFLAGS = $(AM_LDFLAGS) -module -version-info 2:0:0
	HwEvtGenInterface_la_LIBADD = $(EVTGENLIBS) $(PYTHIA8LIB)
	HwEvtGenInterface_la_CPPFLAGS = $(AM_CPPFLAGS) $(EVTGENINCLUDE) \
	--DEVTGEN_PREFIX="\"$(EVTGENPREFIX)\"" \
	+-DEVTGEN_SHARE="\"$(EVTGENSHARE)\"" \
	-DPYTHIA8DATA="\"$(PYTHIA8DATA)\""
	diff --git a/m4/herwig.m4 b/m4/herwig.m4
	--- a/m4/herwig.m4
	+++ b/m4/herwig.m4
	@@ -1,1003 +1,1009 @@
	dnl ##### THEPEG #####
	AC_DEFUN([HERWIG_CHECK_THEPEG],
	[
	defaultlocation="${prefix}"
	test "x$defaultlocation" = xNONE && defaultlocation="${ac_default_prefix}"
	AC_MSG_CHECKING([for libThePEG in])
	AC_ARG_WITH(thepeg,
	AC_HELP_STRING([--with-thepeg=DIR],[location of ThePEG installation]),
	[],
	[with_thepeg="${defaultlocation}"])
	AC_MSG_RESULT([$with_thepeg])

	if test "x$with_thepeg" = "xno"; then
	AC_MSG_ERROR([Cannot build Herwig without ThePEG. Please set --with-thepeg.])
	fi

	THEPEGLDFLAGS="-L${with_thepeg}/lib/ThePEG"

	THEPEGHASLHAPDF="no"
	if test -e ${with_thepeg}/lib/ThePEG/ThePEGLHAPDF.so ; then
	THEPEGHASLHAPDF="yes"
	fi
	if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
	THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
	if test -e ${with_thepeg}/lib64/ThePEG/ThePEGLHAPDF.so ; then
	THEPEGHASLHAPDF="yes"
	fi
	fi

	if test "x$THEPEGHASLHAPDF" == "xno" ; then
	AC_MSG_ERROR([Herwig requires ThePEG to be build with lhapdf.])
	fi

	THEPEGHASFASTJET="no"
	if test -e ${with_thepeg}/lib/ThePEG/FastJetFinder.so ; then
	THEPEGHASFASTJET="yes"
	fi
	if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
	THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
	if test -e ${with_thepeg}/lib64/ThePEG/FastJetFinder.so ; then
	THEPEGHASFASTJET="yes"
	fi
	fi

	if test "x$THEPEGHASFASTJET" == "xno" ; then
	AC_MSG_ERROR([Herwig requires ThePEG to be build with FastJet.])
	fi

	THEPEGPATH="${with_thepeg}"

	oldldflags="$LDFLAGS"
	oldlibs="$LIBS"

	LDFLAGS="$LDFLAGS $THEPEGLDFLAGS"
	AC_CHECK_LIB([ThePEG],[debugThePEG],[],
	[AC_MSG_ERROR([No ThePEG libraries in $THEPEGLDFLAGS. Please set --with-thepeg.])])

	AC_SUBST([THEPEGLIB],[-lThePEG])
	AC_SUBST(THEPEGLDFLAGS)
	AC_SUBST(THEPEGPATH)
	AC_SUBST(THEPEGHASLHAPDF)
	AC_SUBST(THEPEGHASFASTJET)

	LIBS="$oldlibs"
	LDFLAGS="$oldldflags"

	AC_MSG_CHECKING([for ThePEG headers in])
	AC_ARG_WITH([thepeg-headers],
	AC_HELP_STRING([--with-thepeg-headers=DIR],[location of ThePEG include directory]),
	[],
	[with_thepeg_headers="${with_thepeg}/include"])
	AC_MSG_RESULT([$with_thepeg_headers])

	if test "x$with_thepeg_headers" = "xno"; then
	AC_MSG_ERROR([Cannot build Herwig without ThePEG headers. Please set --with-thepeg-headers.])
	fi

	THEPEGINCLUDE="-I$with_thepeg_headers"

	oldcppflags="$CPPFLAGS"
	CPPFLAGS="$CPPFLAGS $THEPEGINCLUDE"
	AC_CHECK_HEADER([ThePEG/Config/ThePEG.h],[],
	[AC_MSG_ERROR([No ThePEG headers in $with_thepeg_headers. Please set --with-thepeg-headers.])])
	CPPFLAGS="$oldcppflags"

	AC_SUBST(THEPEGINCLUDE)

	AC_MSG_CHECKING([for HepMCAnalysis.so in ThePEG])

	THEPEGHASHEPMC="no"
	if test -e ${with_thepeg}/lib/ThePEG/HepMCAnalysis.so ; then
	THEPEGHASHEPMC="yes"
	fi
	if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
	THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
	if test -e ${with_thepeg}/lib64/ThePEG/HepMCAnalysis.so ; then
	THEPEGHASHEPMC="yes"
	fi
	fi

	if test "x$THEPEGHASHEPMC" == "xno" ; then
	CREATE_HEPMC="# create"
	AC_MSG_RESULT([not found])
	else
	CREATE_HEPMC="create"
	AC_MSG_RESULT([found])
	fi

	AC_SUBST([CREATE_HEPMC])

	AC_MSG_CHECKING([for RivetAnalysis.so in ThePEG])

	THEPEGHASRIVET="no"
	if test -e ${with_thepeg}/lib/ThePEG/RivetAnalysis.so ; then
	THEPEGHASRIVET="yes"
	fi
	if test "${host_cpu}" == "x86_64" -a -e ${with_thepeg}/lib64/ThePEG/libThePEG.so ; then
	THEPEGLDFLAGS="-L${with_thepeg}/lib64/ThePEG"
	if test -e ${with_thepeg}/lib64/ThePEG/RivetAnalysis.so ; then
	THEPEGHASRIVET="yes"
	fi
	fi

	if test "x$THEPEGHASRIVET" == "xno" ; then
	CREATE_RIVET="# create"
	AC_MSG_RESULT([not found])
	else
	CREATE_RIVET="create"
	AC_MSG_RESULT([found])
	fi

	AM_CONDITIONAL(HAVE_RIVET,[test x$THEPEGHASRIVET = xyes])
	AC_SUBST([CREATE_RIVET])
	])

	dnl ##### LOOPTOOLS #####
	AC_DEFUN([HERWIG_LOOPTOOLS],
	[
	AC_REQUIRE([AC_PROG_FC])
	AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])
	AC_REQUIRE([AC_PROG_CC])
	AC_REQUIRE([HERWIG_COMPILERFLAGS])

	AC_MSG_CHECKING([if Looptools build works])
	enable_looptools=yes

	if test "x$GCC" = "xyes"; then
	case "${host}" in
	x86_64-\|-darwin1*)
	AM_FCFLAGS="$AM_FCFLAGS -fdefault-integer-8"
	;;
	esac

	AC_LANG_PUSH([Fortran])
	oldFCFLAGS="$FCFLAGS"
	FCFLAGS="$AM_FCFLAGS"
	AC_COMPILE_IFELSE(
	AC_LANG_PROGRAM([],[ print *[,]"Hello"]),
	[],
	[AC_MSG_RESULT([no])
	AC_MSG_ERROR([needs gfortran on 64bit machines])]
	)
	FCFLAGS="$oldFCFLAGS"
	AC_LANG_POP([Fortran])
	fi
	AC_MSG_RESULT([$enable_looptools])

	AC_LANG_PUSH([Fortran])
	AC_MSG_CHECKING([checking if fortran compiler compiles argument mismatches])
	AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
	program temp
	call a(1.0D0)
	end program
	subroutine a(b)
	double complex b
	end]]),
	[AC_MSG_RESULT([yes])],
	[oldFCFLAGS="$FCFLAGS"
	FCFLAGS="-std=legacy"
	AC_MSG_CHECKING([checking if fortran compiler compiles argument mismatches with -std=legacy])
	AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
	program temp
	double precision b
	double complex c
	b = 1.0D0
	c =1.0D0
	call a(b)
	call a(c)
	end program
	subroutine a(b)
	double complex b
	end]]),
	[AC_MSG_RESULT([yes])
	AM_FCFLAGS="$AM_FCFLAGS -std=legacy"],
	[AC_MSG_RESULT([no])
	AC_MSG_ERROR([fortran compiler won't compile LoopTools])])
	FCFLAGS="$oldFCFLAGS -std=legacy"]
	)

	AC_MSG_CHECKING([checking if fortran compiler compiles long lines])
	AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
	program temp
	write (,) 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
	end program]]),
	[AC_MSG_RESULT([yes])],
	[AC_MSG_RESULT([no])
	oldFCFLAGS="$FCFLAGS"
	FCFLAGS="-ffixed-line-length-none"
	AC_MSG_CHECKING([checking if fortran compiler compiles long lines with -ffixed-line-length-none])
	AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
	program temp
	write (,) 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
	end program]]),
	[AC_MSG_RESULT([yes])
	AM_FCFLAGS="$AM_FCFLAGS -ffixed-line-length-none"
	FCFLAGS="$oldFCFLAGS -ffixed-line-length-none"],
	[FCFLAGS="-132"
	AC_MSG_CHECKING([checking if fortran compiler compiles long lines with -132])
	AC_COMPILE_IFELSE(AC_LANG_SOURCE([[
	program temp
	write (,) 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
	end program]]),
	[AC_MSG_RESULT([yes])
	AM_FCFLAGS="$AM_FCFLAGS -132"
	FCFLAGS="$oldFCFLAGS -132"],
	[AC_MSG_RESULT([no])
	AC_MSG_ERROR([fortran compiler won't compile LoopTools])])])
	]
	)





	AC_LANG_POP([Fortran])


	AC_SUBST([F77],[$FC])
	AC_SUBST([FFLAGS],[$FCFLAGS])
	AC_SUBST([AM_FFLAGS],[$AM_FCFLAGS])
	AC_SUBST([FLIBS],[$FCLIBS])
	])

	dnl ##### VBFNLO #####
	AC_DEFUN([HERWIG_CHECK_VBFNLO],
	[
	AC_MSG_CHECKING([for VBFNLO])

	AC_ARG_WITH([vbfnlo],
	AS_HELP_STRING([--with-vbfnlo=DIR], [Installation path of VBFNLO]),
	[],
	[with_vbfnlo=no]

	)

	AC_MSG_RESULT([$with_vbfnlo])

	AS_IF([test "x$with_vbfnlo" != "xno"],
	[AC_CHECK_FILES(
	${with_vbfnlo}/lib/VBFNLO/libVBFNLO.so,
	[have_vbfnlo=lib], [have_vbfnlo=no])],
	[have_vbfnlo=no])

	AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno" ],
	[AC_CHECK_FILES(
	${with_vbfnlo}/lib64/VBFNLO/libVBFNLO.so,
	[have_vbfnlo=lib64], [have_vbfnlo=no])])

	AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno" ],
	[AC_CHECK_FILES(
	${with_vbfnlo}/lib/VBFNLO/libVBFNLO.dylib,
	[have_vbfnlo=lib], [have_vbfnlo=no])])

	AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno" ],
	[AC_CHECK_FILES(
	${with_vbfnlo}/lib64/VBFNLO/libVBFNLO.dylib,
	[have_vbfnlo=lib64], [have_vbfnlo=no])])

	AS_IF([test "x$have_vbfnlo" = "xlib"],
	[VBFNLOLIBS=${with_vbfnlo}/lib/VBFNLO
	AC_SUBST(VBFNLOLIBS)
	])

	AS_IF([test "x$have_vbfnlo" = "xlib64"],
	[VBFNLOLIBS=${with_vbfnlo}/lib64/VBFNLO
	AC_SUBST(VBFNLOLIBS)
	])

	AS_IF([test "x$with_vbfnlo" != "xno" -a "x$have_vbfnlo" = "xno"],
	[AC_MSG_ERROR([vbfnlo requested but not found])])

	AM_CONDITIONAL(HAVE_VBFNLO,[test "x$have_vbfnlo" = "xlib" -o "x$have_vbfnlo" = "xlib64"])

	if test "x$have_vbfnlo" = "xlib" -o "x$have_vbfnlo" = "xlib64" ; then
	AC_REQUIRE([AC_PROG_SED])
	VBFNLOINCLUDE=${with_vbfnlo}/include
	AC_SUBST(VBFNLOINCLUDE)
	VBFNLOLIB=$(echo ${with_vbfnlo}/${have_vbfnlo}/VBFNLO \| $SED -e 's%/\+%/%g')
	AC_SUBST(VBFNLOLIB)
	LOAD_VBFNLO="library"
	CREATE_VBFNLO="create"
	INSERT_VBFNLO="insert"
	SET_VBFNLO="set"
	DO_VBFNLO="do"
	MKDIR_VBFNLO="mkdir"
	else
	LOAD_VBFNLO="# library"
	CREATE_VBFNLO="# create"
	INSERT_VBFNLO="# insert"
	SET_VBFNLO="# set"
	DO_VBFNLO="# do"
	MKDIR_VBFNLO="# mkdir"
	fi

	AC_SUBST([LOAD_VBFNLO])
	AC_SUBST([CREATE_VBFNLO])
	AC_SUBST([INSERT_VBFNLO])
	AC_SUBST([SET_VBFNLO])
	AC_SUBST([DO_VBFNLO])
	AC_SUBST([MKDIR_VBFNLO])

	])

	dnl ##### njet #####
	AC_DEFUN([HERWIG_CHECK_NJET],
	[
	AC_MSG_CHECKING([for njet])

	AC_ARG_WITH([njet],
	AS_HELP_STRING([--with-njet=DIR], [Installation path of njet]),
	[],
	[with_njet=no]

	)

	AC_MSG_RESULT([$with_njet])

	AS_IF([test "x$with_njet" != "xno"],
	[AC_CHECK_FILES(
	${with_njet}/lib/libnjet2.so,
	[have_njet=lib], [have_njet=no])],
	[have_njet=no])

	AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
	[AC_CHECK_FILES(
	${with_njet}/lib64/libnjet2.so,
	[have_njet=lib64], [have_njet=no])])

	AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
	[AC_CHECK_FILES(
	${with_njet}/lib/libnjet2.dylib,
	[have_njet=lib], [have_njet=no])])

	AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
	[AC_CHECK_FILES(
	${with_njet}/lib/libnjet3.so,
	[have_njet=lib], [have_njet=no])])

	AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
	[AC_CHECK_FILES(
	${with_njet}/lib64/libnjet3.so,
	[have_njet=lib], [have_njet=no])])

	AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno" ],
	[AC_CHECK_FILES(
	${with_njet}/lib/libnjet3.dylib,
	[have_njet=lib], [have_njet=no])])

	AS_IF([test "x$with_njet" != "xno" ],
	[AC_CHECK_FILES(
	${with_njet}/include/njet.h,
	[njet_include=include], [njet_include=include/njet])])

	AS_IF([test "x$have_njet" = "xlib"],
	[NJETLIBPATH=${with_njet}/lib
	AC_SUBST(NJETLIBPATH)
	NJETINCLUDEPATH=${with_njet}/$njet_include
	AC_SUBST(NJETINCLUDEPATH)
	NJETPREFIX=${with_njet}
	AC_SUBST(NJETPREFIX)
	])

	AS_IF([test "x$have_njet" = "xlib64"],
	[NJETLIBPATH=${with_njet}/lib64
	AC_SUBST(NJETLIBPATH)
	NJETINCLUDEPATH=${with_njet}/$njet_include
	AC_SUBST(NJETINCLUDEPATH)
	NJETPREFIX=${with_njet}
	AC_SUBST(NJETPREFIX)
	])

	AS_IF([test "x$with_njet" != "xno" -a "x$have_njet" = "xno"],
	[AC_MSG_ERROR([njet requested but not found])])

	AM_CONDITIONAL(HAVE_NJET,[test "x$have_njet" = "xlib" -o "x$have_njet" = "xlib64"])

	AS_IF([test "x$with_njet" != "xno"],[AC_MSG_CHECKING([for Njet version])
	tmp_njetversion=[$(${with_njet}/bin/njet.py --version 2>&1 \| grep -oE '[0-9]{4}$')]
	AS_IF([test -z "$tmp_njetversion"],
	[tmp_njetversion=1023])
	AC_MSG_RESULT([${tmp_njetversion}])
	NJET_VERSION=${tmp_njetversion}
	AC_SUBST(NJET_VERSION)
	])

	if test "x$have_njet" = "xlib" -o "x$have_njet" = "xlib64" ; then
	LOAD_NJET="library"
	CREATE_NJET="create"
	INSERT_NJET="insert"
	DO_NJET="do"
	else
	LOAD_NJET="# library"
	CREATE_NJET="# create"
	INSERT_NJET="# insert"
	DO_NJET="# do"
	fi

	AC_SUBST([LOAD_NJET])
	AC_SUBST([CREATE_NJET])
	AC_SUBST([INSERT_NJET])
	AC_SUBST([DO_NJET])

	])



	dnl ##### gosam #####
	AC_DEFUN([HERWIG_CHECK_GOSAM],
	[
	AC_MSG_CHECKING([for GoSam])

	AC_ARG_WITH([gosam],
	AS_HELP_STRING([--with-gosam=DIR], [Installation path of GoSam]),
	[],
	[with_gosam=no]
	)

	AC_MSG_RESULT([$with_gosam])

	AS_IF([test "x$with_gosam" != "xno"],
	[AC_CHECK_FILES(
	${with_gosam}/bin/gosam.py,
	[have_gosam=lib], [have_gosam=no])],
	[have_gosam=no])

	AS_IF([test "x$have_gosam" = "xlib"],
	[GOSAMPREFIX=${with_gosam}
	AC_SUBST(GOSAMPREFIX)
	])

	AS_IF([test "x$with_gosam" != "xno" -a "x$have_gosam" = "xno"],
	[AC_MSG_ERROR([GoSam requested but not found])])

	AS_IF([test "x$with_gosam" != "xno"],
	[AC_MSG_CHECKING([for GoSam version >= 2.0.4])
	tmp_gosamversion=[$(${with_gosam}/bin/gosam.py --version \| grep 'GoSam.*rev' \| cut -d' ' -f2)]
	AX_COMPARE_VERSION([${tmp_gosamversion}],[lt],[2.0.4],
	[AC_MSG_RESULT([no])
	AC_MSG_ERROR([Herwig requires GoSam 2.0.4 or later, found ${tmp_gosamversion}])],
	[AC_MSG_RESULT([yes])])])

	AM_CONDITIONAL(HAVE_GOSAM,[test "x$have_gosam" = "xlib" ])

	if test "x$have_gosam" = "xlib" ; then
	LOAD_GOSAM="library"
	CREATE_GOSAM="create"
	INSERT_GOSAM="insert"
	DO_GOSAM="do"
	else
	LOAD_GOSAM="# library"
	CREATE_GOSAM="# create"
	INSERT_GOSAM="# insert"
	DO_GOSAM="# do"
	fi

	AC_SUBST([LOAD_GOSAM])
	AC_SUBST([CREATE_GOSAM])
	AC_SUBST([INSERT_GOSAM])
	AC_SUBST([DO_GOSAM])


	])


	dnl ##### gosam-contrib #####
	AC_DEFUN([HERWIG_CHECK_GOSAM_CONTRIB],
	[
	AC_MSG_CHECKING([for gosam-contrib])

	AC_ARG_WITH([gosam-contrib],
	AS_HELP_STRING([--with-gosam-contrib=DIR], [Installation path of gosam-contrib]),
	[],
	[with_gosam_contrib=no]
	)

	AC_MSG_RESULT([$with_gosam_contrib])

	AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
	[AC_CHECK_FILES(
	${with_gosam}/lib/libsamurai.so,
	[with_gosam_contrib=${with_gosam}], [])
	])

	AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
	[AC_CHECK_FILES(
	${with_gosam}/lib64/libsamurai.so,
	[with_gosam_contrib=${with_gosam}], [])
	])

	AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
	[AC_CHECK_FILES(
	${with_gosam}/lib/libsamurai.dylib,
	[with_gosam_contrib=${with_gosam}], [])
	])

	AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
	[AC_CHECK_FILES(
	${with_gosam}/lib64/libsamurai.dylib,
	[with_gosam_contrib=${with_gosam}], [])
	])

	AS_IF([test "x$with_gosam_contrib" = "xno" -a "x$with_gosam" != "xno"],
	[AC_MSG_ERROR([GoSam requested without requesting GoSam-Contrib])])

	AS_IF([test "x$with_gosam_contrib" != "xno"],
	[AC_CHECK_FILES(
	${with_gosam_contrib}/lib/libsamurai.so,
	[have_gosam_contrib=lib], [have_gosam_contrib=no])],
	[have_gosam_contrib=no])

	AS_IF([test "x$with_gosam_contrib" != "xno" -a "x$have_gosam_contrib" = "xno" ],
	[AC_CHECK_FILES(
	${with_gosam_contrib}/lib64/libsamurai.so,
	[have_gosam_contrib=lib64], [have_gosam_contrib=no])])

	AS_IF([test "x$with_gosam_contrib" != "xno" -a "x$have_gosam_contrib" = "xno" ],
	[AC_CHECK_FILES(
	${with_gosam_contrib}/lib/libsamurai.dylib,
	[have_gosam_contrib=lib], [have_gosam_contrib=no])])

	AS_IF([test "x$with_gosam_contrib" != "xno" -a "x$have_gosam_contrib" = "xno" ],
	[AC_CHECK_FILES(
	${with_gosam_contrib}/lib64/libsamurai.dylib,
	[have_gosam_contrib=lib64], [have_gosam_contrib=no])])







	AS_IF([test "x$have_gosam_contrib" != "xno"],
	[GOSAMCONTRIBPREFIX=${with_gosam_contrib}
	AC_SUBST(GOSAMCONTRIBPREFIX)
	])

	AS_IF([test "x$have_gosam_contrib" = "xlib"],
	[GOSAMCONTRIBLIBS=${with_gosam_contrib}/lib
	AC_SUBST(GOSAMCONTRIBLIBS)
	])

	AS_IF([test "x$have_gosam_contrib" = "xlib64"],
	[GOSAMCONTRIBLIBS=${with_gosam_contrib}/lib64
	AC_SUBST(GOSAMCONTRIBLIBS)
	])

	AS_IF([test "x$with_gosam_contrib" != "xno" -a "x$have_gosam_contrib" = "xno"],
	[AC_MSG_ERROR([GoSam-Contrib requested but not found])])

	AM_CONDITIONAL(HAVE_GOSAM_CONTRIB,[test "x$have_gosam_contrib" = "xlib" -o "x$have_gosam_contrib" = "xlib64"])

	if test "x$have_gosam_contrib" = "xlib" -o "x$have_gosam_contrib" = "xlib64" ; then
	LOAD_GOSAM_CONTRIB="library"
	CREATE_GOSAM_CONTRIB="create"
	INSERT_GOSAM_CONTRIB="insert"
	else
	LOAD_GOSAM_CONTRIB="# library"
	CREATE_GOSAM_CONTRIB="# create"
	INSERT_GOSAM_CONTRIB="# insert"
	fi

	AC_SUBST([LOAD_GOSAM_CONTRIB])
	AC_SUBST([CREATE_GOSAM_CONTRIB])
	AC_SUBST([INSERT_GOSAM_CONTRIB])


	])


	dnl ##### OpenLoops #####
	AC_DEFUN([HERWIG_CHECK_OPENLOOPS],
	[
	AC_MSG_CHECKING([for OpenLoops])

	AC_ARG_WITH([openloops],
	AS_HELP_STRING([--with-openloops=DIR], [Installation path of OpenLoops]),
	[],
	[with_openloops=no]

	)

	AC_MSG_RESULT([$with_openloops])

	AS_IF([test "x$with_openloops" != "xno"],
	[AC_CHECK_FILES(
	${with_openloops}/lib/libopenloops.so,
	[have_openloops=lib], [have_openloops=no])],
	[have_openloops=no])

	AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno" ],
	[AC_CHECK_FILES(
	${with_openloops}/lib/libopenloops.dylib,
	[have_openloops=lib], [have_openloops=no])])

	AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno" ],
	[AC_CHECK_FILES(
	${with_openloops}/lib64/libopenloops.so,
	[have_openloops=lib64], [have_openloops=no])])


	AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno" ],
	[AC_CHECK_FILES(
	${with_openloops}/lib64/libopenloops.dylib,
	[have_openloops=lib64], [have_openloops=no])])





	AS_IF([test "x$have_openloops" = "xlib"],
	[OPENLOOPSLIBS=${with_openloops}/lib
	AC_SUBST(OPENLOOPSLIBS)
	])

	AS_IF([test "x$have_openloops" = "xlib64"],
	[OPENLOOPSLIBS=${with_openloops}/lib64
	AC_SUBST(OPENLOOPSLIBS)
	])

	AS_IF([test "x$with_openloops" != "xno" -a "x$have_openloops" = "xno"],
	[AC_MSG_ERROR([OpenLoops requested but not found])])

	AM_CONDITIONAL(HAVE_OPENLOOPS,[test "x$have_openloops" = "xlib" -o "x$have_openloops" = "xlib64"])

	if test "x$have_openloops" = "xlib" -o "x$have_openloops" = "xlib64" ; then
	OPENLOOPSPREFIX=${with_openloops}
	LOAD_OPENLOOPS="library"
	CREATE_OPENLOOPS="create"
	INSERT_OPENLOOPS="insert"
	SET_OPENLOOPS="set"
	DO_OPENLOOPS="do"
	MKDIR_OPENLOOPS="mkdir"
	else
	LOAD_OPENLOOPS="# library"
	CREATE_OPENLOOPS="# create"
	INSERT_OPENLOOPS="# insert"
	SET_OPENLOOPS="# set"
	DO_OPENLOOPS="# do"
	MKDIR_OPENLOOPS="# mkdir"
	fi

	AC_SUBST([OPENLOOPSPREFIX])
	AC_SUBST([LOAD_OPENLOOPS])
	AC_SUBST([CREATE_OPENLOOPS])
	AC_SUBST([INSERT_OPENLOOPS])
	AC_SUBST([SET_OPENLOOPS])
	AC_SUBST([DO_OPENLOOPS])
	AC_SUBST([MKDIR_OPENLOOPS])

	])

	#########################################

	dnl ##### madgraph #####
	AC_DEFUN([HERWIG_CHECK_MADGRAPH],
	[
	AC_MSG_CHECKING([for MadGraph])

	AC_ARG_WITH([madgraph],
	AS_HELP_STRING([--with-madgraph=DIR], [Installation path of MadGraph]),
	[],
	[with_madgraph=no]
	)

	AC_MSG_RESULT([$with_madgraph])

	AS_IF([test "x$with_madgraph" != "xno"],
	[AC_CHECK_FILES(
	${with_madgraph}/bin/mg5_aMC,
	[have_madgraph=yes], [have_madgraph=no])],
	[have_madgraph=no])

	AS_IF([test "x$have_madgraph" = "xyes"],
	[MADGRAPHPREFIX=${with_madgraph}
	AC_SUBST(MADGRAPHPREFIX)
	])

	AS_IF([test "x$with_madgraph" != "xno" -a "x$have_madgraph" = "xno"],
	[AC_MSG_ERROR([MadGraph requested but not found])])

	AM_CONDITIONAL(HAVE_MADGRAPH,[test "x$have_madgraph" = "xyes" ])

	if test "x$have_madgraph" = "xyes" ; then
	LOAD_MADGRAPH="library"
	CREATE_MADGRAPH="create"
	INSERT_MADGRAPH="insert"
	SET_MADGRAPH="set"
	DO_MADGRAPH="do"
	else
	LOAD_MADGRAPH="# library"
	CREATE_MADGRAPH="# create"
	INSERT_MADGRAPH="# insert"
	SET_MADGRAPH="# set"
	DO_MADGRAPH="# do"
	fi

	AC_SUBST([LOAD_MADGRAPH])
	AC_SUBST([CREATE_MADGRAPH])
	AC_SUBST([INSERT_MADGRAPH])
	AC_SUBST([SET_MADGRAPH])
	AC_SUBST([DO_MADGRAPH])

	])


	AC_DEFUN([HERWIG_CHECK_PYTHIA],
	[
	dnl check if a directory is specified for Pythia
	AC_ARG_WITH(pythia,
	[AC_HELP_STRING([--with-pythia=dir],
	[Assume the given directory for Pythia])])

	dnl search for the pythia-config script
	if test "$with_pythia" = ""; then
	AC_PATH_PROG(pythiaconfig, pythia8-config, no)
	else
	AC_PATH_PROG(pythiaconfig, pythia8-config, no, ${with_pythia}/bin)
	fi

	if test "${pythiaconfig}" = "no"; then
	AC_MSG_CHECKING(Pythia)
	AC_MSG_RESULT(no);
	PYTHIA8LIB=
	# $2
	else
	PYTHIA8DATA=`${pythiaconfig} --datadir`/xmldoc
	PYTHIA8LIB="-L`${pythiaconfig} --libdir` -lpythia8"
	fi

	AC_SUBST(PYTHIA8DATA)
	AC_SUBST(PYTHIA8LIB)

	])

	dnl CHECK PYTHIA END

	dnl ##### EvtGen #####
	AC_DEFUN([HERWIG_CHECK_EVTGEN],
	[
	AC_MSG_CHECKING([for evtgen])

	AC_ARG_WITH([evtgen],
	AS_HELP_STRING([--with-evtgen=DIR], [Installation path of EvtGen]),
	[],
	[with_evtgen=no]
	)

	AC_MSG_RESULT([$with_evtgen])

	AS_IF([test "x$with_evtgen" != "xno"],
	[AC_CHECK_FILES(
	${with_evtgen}/lib/libEvtGenExternal.so,
	[have_evtgen=lib], [have_evtgen=no])],
	[have_evtgen=no])

	AS_IF([test "x$with_evtgen" != "xno" -a "x$have_evtgen" = "xno"],
	[AC_CHECK_FILES(
	${with_evtgen}/lib64/libEvtGenExternal.so,
	[have_evtgen=lib64], [have_evtgen=no])])

	AS_IF([test "x$with_evtgen" != "xno" -a "x$have_evtgen" = "xno" ],
	[AC_CHECK_FILES(
	${with_evtgen}/lib/libEvtGenExternal.dylib,
	[have_evtgen=lib], [have_evtgen=no])])

	AS_IF([test "x$have_evtgen" = "xlib" -o "x$have_evtgen" = "xlib64" ],
	[EVTGENPREFIX=${with_evtgen}
	AC_SUBST(EVTGENPREFIX)
	])
	+
	+AS_IF([test "x$have_evtgen" = "xlib" -o "x$have_evtgen" = "xlib64" ],
	+ [AC_CHECK_FILES(
	+ ${with_evtgen}/share/evt.pdl,
	+ [EVTGENSHARE=${with_evtgen}/share], [EVTGENSHARE=${with_evtgen}/share/EvtGen])
	+ AC_SUBST(EVTGENSHARE)])

	AS_IF([test "x$with_evtgen" != "xno" -a "x$have_evtgen" = "xno"],
	[AC_MSG_ERROR([EvtGen requested but not found])])

	AC_SUBST([EVTGENINCLUDE],[-I$EVTGENPREFIX/include])

	AM_CONDITIONAL(HAVE_EVTGEN,[test "x$have_evtgen" = "xlib" -o "x$have_evtgen" = "xlib64"])

	if test "x$have_evtgen" = "xlib" ; then
	LOAD_EVTGEN_DECAYS="read EvtGenBDecays.in"
	LOAD_EVTGEN_DECAYER="read EvtGenDecayer.in"
	EVTGENLIBS="-L$with_evtgen/lib -lEvtGen -lEvtGenExternal"
	elif test "x$have_evtgen" = "xlib64" ; then
	LOAD_EVTGEN_DECAYS="read EvtGenBDecays.in"
	LOAD_EVTGEN_DECAYER="read EvtGenDecayer.in"
	EVTGENLIBS="-L$with_evtgen/lib64 -lEvtGen -lEvtGenExternal"
	else
	LOAD_EVTGEN_DECAYS="read HerwigBDecays.in"
	LOAD_EVTGEN_DECAYER="#read EvtGenDecayer.in"
	EVTGENLIBS=""
	fi

	AC_SUBST([LOAD_EVTGEN_DECAYS])
	AC_SUBST([LOAD_EVTGEN_DECAYER])
	AC_SUBST([EVTGENLIBS])


	])

	dnl ###### GSL ######
	AC_DEFUN([HERWIG_CHECK_GSL],
	[
	AC_MSG_CHECKING([for gsl location])
	GSLINCLUDE=""
	GSLLIBS=""

	AC_ARG_WITH(gsl,
	AC_HELP_STRING([--with-gsl=DIR],[location of gsl installation @<:@default=system libs@:>@]),
	[],
	[with_gsl=system])

	if test "x$with_gsl" = "xno"; then
	AC_MSG_ERROR([libgsl is required. Please install the GNU scientific library and header files.])
	fi

	if test "x$with_gsl" = "xsystem"; then
	AC_MSG_RESULT([in system libraries])
	oldlibs="$LIBS"
	AC_CHECK_LIB(m,main)
	AC_CHECK_LIB(gslcblas,main)
	AC_CHECK_LIB(gsl,main,[],
	[
	AC_MSG_ERROR([Cannot find libgsl. Please install the GNU scientific library and header files or use --with-gsl=.])
	]
	)
	GSLLIBS="$LIBS"
	GSLPATH="$with_gsl"
	LIBS=$oldlibs
	else
	if test "`uname -m`" = "x86_64" -a -e "$with_gsl/lib64/libgsl.a" -a -d "$with_gsl/include/gsl"; then
	AC_MSG_RESULT([found in $with_gsl])
	GSLLIBS="-L$with_gsl/lib64 -R$with_gsl/lib64 -lgslcblas -lgsl"
	GSLINCLUDE="-I$with_gsl/include"
	GSLPATH="$with_gsl"
	elif test -e "$with_gsl/lib/libgsl.a" -a -d "$with_gsl/include/gsl"; then
	AC_MSG_RESULT([found in $with_gsl])
	GSLLIBS="-L$with_gsl/lib -R$with_gsl/lib -lgslcblas -lgsl"
	GSLINCLUDE="-I$with_gsl/include"
	GSLPATH="$with_gsl"
	else
	AC_MSG_RESULT([not found])
	AC_MSG_ERROR([Can't find $with_gsl/lib/libgsl.a or the headers in $with_gsl/include])
	fi
	fi

	AC_SUBST(GSLINCLUDE)
	AC_SUBST(GSLLIBS)
	AC_SUBST(GSLPATH)
	])

	dnl ##### COMPILERFLAGS #####
	AC_DEFUN([HERWIG_COMPILERFLAGS],
	[
	AC_REQUIRE([HERWIG_CHECK_GSL])
	AC_REQUIRE([HERWIG_CHECK_THEPEG])
	AC_REQUIRE([BOOST_REQUIRE])
	AC_REQUIRE([AX_COMPILER_VENDOR])

	AM_CPPFLAGS="-I\$(top_builddir)/include $THEPEGINCLUDE \$(GSLINCLUDE) \$(BOOST_CPPFLAGS)"

	AC_MSG_CHECKING([for debugging mode])
	AC_ARG_ENABLE(debug,
	AC_HELP_STRING([--enable-debug],[debug mode, use --enable-debug=slow for additional options that slow down the run.]),
	[],
	[enable_debug=no]
	)
	AC_MSG_RESULT([$enable_debug])

	if test "x$enable_debug" = "xno"; then
	debugflags=""
	else
	debugflags="-g"
	fi

	dnl -Wfloat-equal -fvisibility-inlines-hidden -Wctor-dtor-privacy -Weffc++
	if test -n "$GCC"; then
	warnflags="-pedantic -Wall -Wextra -Wno-overloaded-virtual"

	if test "x$enable_debug" = "xslow"; then
	debugflags="$debugflags -fno-inline"
	AM_CPPFLAGS="$AM_CPPFLAGS -D_GLIBCXX_DEBUG"
	fi
	fi

	dnl do an actual capability check on ld instead of this workaround
	case "${host}" in
	-darwin)
	;;
	*)
	AM_LDFLAGS="-Wl,--enable-new-dtags"
	;;
	esac

	case "${ax_cv_cxx_compiler_vendor}" in
	gnu)
	AM_CXXFLAGS="-pedantic -Wall -W"
	;;
	clang)
	AM_CXXFLAGS="-pedantic -Wall -Wno-overloaded-virtual -Wno-unused-function -Wno-unused-parameter"
	dnl -Wno-unneeded-internal-declaration
	;;
	intel)
	AM_CXXFLAGS="-strict-ansi -Wall -wd13000,1418,981,444,383,1599,1572,2259,980"
	;;
	esac



	AC_SUBST(AM_CPPFLAGS)
	AC_SUBST(AM_CFLAGS, ["$warnflags $debugflags"])
	AC_SUBST(AM_CXXFLAGS,["$AM_CXXFLAGS $warnflags $debugflags"])
	AC_SUBST(AM_FCFLAGS, ["$debugflags"])
	AC_SUBST(AM_LDFLAGS)
	])

	AC_DEFUN([HERWIG_ENABLE_MODELS],
	[
	AC_MSG_CHECKING([if BSM models should be built])

	AC_ARG_ENABLE(models,
	AC_HELP_STRING([--disable-models],[Turn off compilation of BSM models.]),
	[],
	[enable_models=yes]
	)
	AC_MSG_RESULT([$enable_models])

	LOAD_BSM=""
	if test "$enable_models" = "yes"; then
	LOAD_BSM="read BSMlibs.in"
	fi
	AC_SUBST(LOAD_BSM)

	AM_CONDITIONAL(WANT_BSM,[test "$enable_models" = "yes"])
	])

	AC_DEFUN([HERWIG_OVERVIEW],
	[
	FCSTRING=`$FC --version \| head -1`
	CXXSTRING=`$CXX --version \| head -1`
	CCSTRING=`$CC --version \| head -1`
	if test "x$PYTHON" != "x:"
	then
	python_was_found="yes, using Python $PYTHON_VERSION"
	else
	python_was_found="no, requires Python >= 2.6"
	fi

	cat << _HW_EOF_ > config.herwig
	*****************************************************
	*** $PACKAGE_STRING configuration summary
	*** Please include this information in bug reports!
	***--------------------------------------------------
	*** Prefix: $prefix
	***
	*** BSM models: $enable_models
	*** UFO converter: ${python_was_found}
	***
	*** Herwig debug mode: $enable_debug
	***
	*** ThePEG: $with_thepeg
	*** ThePEG headers: $with_thepeg_headers
	***
	*** GoSam: $with_gosam
	*** GoSam-Contrib: $with_gosam_contrib
	*** MadGraph: $with_madgraph
	*** njet: $with_njet ${NJET_VERSION}
	*** OpenLoops: $with_openloops
	*** VBFNLO: $with_vbfnlo
	***
	*** EvtGen: $with_evtgen
	*** GSL: $with_gsl
	*** boost: ${BOOST_CPPFLAGS:-system}
	*** Fastjet: ${fjconfig}
	***
	*** Host: $host
	*** CC: $CCSTRING
	*** CXX: $CXXSTRING
	*** FC: $FCSTRING
	***
	*** CXXFLAGS: $CXXFLAGS
	*** FCFLAGS: $FCFLAGS
	*****************************************************
	_HW_EOF_
	])

File Metadata

Mime Type: text/x-diff
Expires: Tue, Nov 19, 5:41 PM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3805432
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions