No OneTemporary
Actions

Size

63 KB

Subscribers

None

View Options

	diff --git a/MatrixElement/FxFx/FxFxEventHandler.h b/MatrixElement/FxFx/FxFxEventHandler.h
	--- a/MatrixElement/FxFx/FxFxEventHandler.h
	+++ b/MatrixElement/FxFx/FxFxEventHandler.h
	@@ -1,448 +1,448 @@
	// -- C++ --
	//
	// FxFxEventHandler.h is a part of ThePEG - Toolkit for HEP Event Generation
	// Copyright (C) 1999-2011 Leif Lonnblad
	//
	// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
	// Please respect the MCnet academic guidelines, see GUIDELINES for details.
	//
	#ifndef THEPEG_FxFxEventHandler_H
	#define THEPEG_FxFxEventHandler_H
	//
	// This is the declaration of the FxFxEventHandler class.
	//

	#include "ThePEG/Handlers/EventHandler.h"
	#include "FxFxEventHandler.fh"
	#include "FxFxReader.fh"
	#include "FxFxAnalysis.h"
	#include "ThePEG/Utilities/CompSelector.h"
	#include "ThePEG/Utilities/XSecStat.h"

	namespace ThePEG {

	/**
	* The FxFxEventHandler inherits from the general EventHandler
	* class and administers the reading of events generated by external
	* matrix element generator programs according to the Les Houches
	* accord.
	*
	* The class has a list of <code>FxFxReader</code>s which
	* typically are connected to files with event data produced by
	* external matrix element generator programs. When an event is
	* requested by FxFxEventHandler, one of the readers are chosen,
	* an event is read in and then passed to the different
	* <code>StepHandler</code> defined in the underlying
	* EventHandler class.
	*
	* @see \ref FxFxEventHandlerInterfaces "The interfaces"
	* defined for FxFxEventHandler.
	*/
	class FxFxEventHandler: public EventHandler {

	public:

	/**
	* A vector of FxFxReader objects.
	*/
	typedef vector<FxFxReaderPtr> ReaderVector;

	/**
	* A selector of readers.
	*/
	typedef CompSelector<int,CrossSection> ReaderSelector;

	/**
	* Enumerate the weighting options.
	*/
	enum WeightOpt {
	unitweight = 1, /*< All events have unit weight. /
	unitnegweight = -1, /*< All events have wight +/- 1. /
	varweight = 2, /*< Varying positive weights. /
	varnegweight = -2 /*< Varying positive or negative weights. /
	};

	friend class FxFxHandler;


	public:

	/** @name Standard constructors and destructors. */
	//@{
	/**
	* The default constructor.
	*/
	FxFxEventHandler()
	: theWeightOption(unitweight), theUnitTolerance(1.0e-6), warnPNum(true), theNormWeight(0)
	{
	selector().tolerance(unitTolerance());
	}

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

	public:

	/** @name Initialization and finalization functions. */
	//@{
	/**
	* Initialize this event handler and all related objects needed to
	* generate events.
	*/
	virtual void initialize();

	/**
	* Write out accumulated statistics about intergrated cross sections
	* and stuff.
	*/
	virtual void statistics(ostream &) 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;

	/**
	* The estimated 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;

	virtual int ntriesinternal() const;

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

	virtual map<string,CrossSection> optintegratedXSecMap() const;

	//@}

	/** @name Functions used for the actual generation */
	//@{
	/**
	* Generate an event.
	*/
	virtual EventPtr generateEvent();

	/**
	* Create the Event and Collision objects. Used by the
	* generateEvent() function.
	*/
	virtual tCollPtr performCollision();

	/**
	* Continue generating an event if the generation has been stopped
	* before finishing.
	*/
	virtual EventPtr continueEvent();
	//@}

	/** @name Functions to manipulate statistics. */
	//@{
	/**
	* An event has been selected. Signal that an event has been
	* selected with the given \a weight. If unit weights are requested,
	* the event will be accepted with that weight. This also takes care
	* of the statistics collection of the selected reader object.
	*/
	void select(double weight);

	/**
	* Accept the current event, taking care of the statistics
	* collection of the corresponding reader objects.
	*/
	void accept();

	/**
	* Reject the current event, taking care of the statistics
	* collection of the corresponding reader objects.
	*/
	void reject(double weight);

	/**
	* Increase the overestimated cross section for the selected reader.
	*/
	void increaseMaxXSec(CrossSection maxxsec);

	/**
	* Skip some events. To ensure a reader file is scanned an even
	* number of times, skip a number of events for the selected reader.
	*/
	void skipEvents();

	//@}

	/** @name Simple access functions. */
	//@{
	/**
	* The way weights are to be treated.
	*/
	WeightOpt weightOption() const { return theWeightOption; }

	/**
	* If the weight option is set to unit weight, do not start
	* compensating unless the weight is this much larger than unity.
	*/
	double unitTolerance() const { return theUnitTolerance; }

	/**
	* Access the list of readers.
	*/
	const ReaderVector & readers() const { return theReaders; }

	/**
	* The selector to choose readers according to their overestimated
	* cross section.
	*/
	const ReaderSelector & selector() const { return theSelector; }

	/**
	* The currently selected reader object.
	*/
	tFxFxReaderPtr currentReader() const { return theCurrentReader; }


	/**
	* Set the currently selected reader object.
	*/
	void currentReader(tFxFxReaderPtr x) { theCurrentReader = x; }

	//@}

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

	/**
	* The currently selected reader object.
	*/
	tFxFxReaderPtr theCurrentReader;



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

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

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

	protected:

	/**
	* Access the list of readers.
	*/
	ReaderVector & readers() { return theReaders; }

	/**
	* The selector to choose readers according to their overestimated
	* cross section.
	*/
	ReaderSelector & selector() { return theSelector; }

	/**
	* Helper function for the interface;
	*/
	void setUnitTolerance(double);

	/**
	* Collect statistics for this event handler.
	*/
	XSecStat stats;

	map<string,XSecStat> optstats;

	map<string,CrossSection> optxs;

	int ntries;

	map<string,XSecStat> OptStatsFunc() { return optstats; }

	map<string,CrossSection> OptXsFunc() { return optxs; }


	/**
	* Collect statistics for this event handler. To be used for
	* histogram scaling.
	*/
	XSecStat histStats;

	map<string,XSecStat> opthistStats;


	/*
	* The weight identifiers for the events
	*/

	vector<string> weightnames;

	private:

	/**
	* The list of readers.
	*/
	ReaderVector theReaders;

	/**
	* The selector to choose readers according to their overestimated
	* cross section.
	*/
	ReaderSelector theSelector;

	/**
	* The way weights are to be treated.
	*/
	WeightOpt theWeightOption;

	/**
	* If the weight option is set to unit weight, do not start
	* compensating unless the weight is this much larger than unity.
	*/
	double theUnitTolerance;


	/**
	* Warn if the same process number is used in more than one
	* FxFxReader.
	*/
	bool warnPNum;

	/**
	* How to normalize the weights
	*/
	unsigned int theNormWeight;


	public:

	/** @cond EXCEPTIONCLASSES */
	/**
	* Exception class used if no readers were assigned.
	*/
	class FxFxInitError: public InitException {};

	/**
	* Exception class used if the same process number is used by more
	* than ne reader.
	*/
	class FxFxPNumException: public InitException {};
	/** @endcond */

	private:

	/**
	* The static object used to initialize the description of this class.
	* Indicates that this is a concrete class with persistent data.
	*/
	static ClassDescription<FxFxEventHandler> initFxFxEventHandler;

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

	};

	}

	// CLASSDOC OFF

	#include "ThePEG/Utilities/ClassTraits.h"

	namespace ThePEG {

	/** @cond TRAITSPECIALIZATIONS */

	/** This template specialization informs ThePEG about the
	* base classes of FxFxEventHandler. */
	template <>
	struct BaseClassTrait<FxFxEventHandler,1> {
	/** Typedef of the first base class of FxFxEventHandler. */
	typedef EventHandler NthBase;
	};

	/** This template specialization informs ThePEG about the name of
	* the FxFxEventHandler class and the shared object where it is defined. */
	template <>
	struct ClassTraits<FxFxEventHandler>
	: public ClassTraitsBase<FxFxEventHandler> {
	/** Return a platform-independent class name */
	static string className() { return "Herwig::FxFxEventHandler"; }
	/** Return the name of the shared library be loaded to get access to
	* the FxFxEventHandler class and every other class it uses
	* (except the base class). */
	- static string library() { return "FxFx.so"; }
	+ static string library() { return "HwFxFx.so"; }
	};

	/** @endcond */

	}

	#endif /* THEPEG_FxFxEventHandler_H */
	diff --git a/MatrixElement/FxFx/FxFxFileReader.h b/MatrixElement/FxFx/FxFxFileReader.h
	--- a/MatrixElement/FxFx/FxFxFileReader.h
	+++ b/MatrixElement/FxFx/FxFxFileReader.h
	@@ -1,333 +1,333 @@
	// -- C++ --
	//
	// FxFxFileReader.h is a part of ThePEG - Toolkit for HEP Event Generation
	// Copyright (C) 1999-2011 Leif Lonnblad
	//
	// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
	// Please respect the MCnet academic guidelines, see GUIDELINES for details.
	//
	#ifndef THEPEG_FxFxFileReader_H
	#define THEPEG_FxFxFileReader_H
	// This is the declaration of the FxFxFileReader class.

	#include "FxFxReader.h"
	#include "FxFxFileReader.fh"
	#include "ThePEG/PDT/Decayer.h"
	#include "ThePEG/Utilities/CFileLineReader.h"
	#include <stdio.h>

	namespace ThePEG {


	/**
	* FxFxFileReader is an base class to be used for objects which
	* reads event files from matrix element generators. It inherits from
	* FxFxReader and extends it by defining a file handle to be
	* read from, which is opened and closed by the open() and close()
	* functions. Note that the file handle is a standard C filehandle and
	* not a C++ stream. This is because there is no standard way in C++
	* to connect a pipe to a stream for reading eg. gzipped files. This
	* class is able to read plain event files conforming to the Les
	* Houches Event File accord.
	*
	* @see \ref FxFxFileReaderInterfaces "The interfaces"
	* defined for FxFxFileReader.
	* @see Event
	* @see FxFxReader
	*/
	class FxFxFileReader: public FxFxReader {

	public:

	/** @name Standard constructors and destructors. */
	//@{
	/**
	* Default constructor.
	*/
	FxFxFileReader() : neve(0), ieve(0), theQNumbers(false), theIncludeFxFxTags(true),
	theIncludeCentral(false) {}

	/**
	* Copy-constructor. Note that a file which is opened in the object
	* copied from will have to be reopened in this.
	*/
	FxFxFileReader(const FxFxFileReader &);

	/**
	* Destructor.
	*/
	virtual ~FxFxFileReader();
	//@}

	public:

	/** @name Virtual functions specified by the FxFxReader base class. */
	//@{
	/**
	* Initialize. This function is called by the FxFxEventHandler
	* to which this object is assigned.
	*/
	virtual void initialize(FxFxEventHandler & eh);

	/**
	* Open a file with events. Derived classes should overwrite it and
	* first calling it before reading in the run information into the
	* corresponding protected variables.
	*/
	virtual void open();

	/**
	* Close the file from which events have been read.
	*/
	virtual void close();


	/**
	* Read the next event from the file or stream into the
	* corresponding protected variables. Return false if there is no
	* more events or if this was not a LHF event file.
	*/
	virtual bool doReadEvent();
	//@}

	/**
	* Return the name of the file from where to read events.
	*/
	string filename() const { return theFileName; }

	/* vector<string> optionalWeightsNames;

	virtual vector<string> optWeightNamesFunc();*/


	virtual vector<string> optWeightsNamesFunc();


	/**
	* Erases all occurences of a substring from a string
	*/

	void erase_substr(std::string& subject, const std::string& search);


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

	/**
	* Standard Init function used to initialize the interfaces.
	*/
	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;
	//@}

	/** @name Standard (and non-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();

	/**
	* Return true if this object needs to be initialized before all
	* other objects because it needs to extract PDFs from the event file.
	*/
	virtual bool preInitialize() const;
	//@

	protected:

	/**
	* The wrapper around the C FILE stream from which to read
	*/
	CFileLineReader cfile;

	protected:

	/**
	* The number of events in this file.
	*/
	long neve;

	/**
	* The current event number.
	*/
	long ieve;

	/**
	* If the file is a standard Les Houches formatted file (LHF) this
	* is its version number. If empty, this is not a Les Houches
	* formatted file
	*/
	string LHFVersion;

	/**
	* If LHF. All lines (since the last open() or readEvent()) outside
	* the header, init and event tags.
	*/
	string outsideBlock;

	/**
	* If LHF. All lines from the header block.
	*/
	string headerBlock;

	/**
	* If LHF. Additional comments found in the init block.
	*/
	string initComments;

	/**
	* If LHF. Map of attributes (name-value pairs) found in the init
	* tag.
	*/
	map<string,string> initAttributes;

	/**
	* If LHF. Additional comments found with the last read event.
	*/
	string eventComments;

	/**
	* If LHF. Map of attributes (name-value pairs) found in the last
	* event tag.
	*/
	map<string,string> eventAttributes;

	private:

	/**
	* The name of the file from where to read events.
	*/
	string theFileName;

	/**
	* Whether or not to search for QNUMBERS stuff
	*/
	bool theQNumbers;

	/**
	* Include/Read FxFx tags
	*/
	bool theIncludeFxFxTags;

	/**
	* Include central weight (for backup use)
	*/
	bool theIncludeCentral;

	/**
	* Decayer for any decay modes read from the file
	*/
	DecayerPtr theDecayer;

	/**
	* Further information on the weights
	*/
	map<string,string> scalemap;

	/**
	* Temporary holder for optional weights
	*/

	map<string,double> optionalWeightsTemp;


	private:

	/**
	* Describe an abstract base class with persistent data.
	*/
	static ClassDescription<FxFxFileReader> initFxFxFileReader;

	/**
	* Private and non-existent assignment operator.
	*/
	FxFxFileReader & operator=(const FxFxFileReader &) = delete;

	public:

	/** @cond EXCEPTIONCLASSES */
	/** Exception class used by FxFxFileReader if reading the file
	* fails. */
	class FxFxFileError: public Exception {};
	/** @endcond */

	};

	}


	#include "ThePEG/Utilities/ClassTraits.h"

	namespace ThePEG {

	/** @cond TRAITSPECIALIZATIONS */

	/**
	* This template specialization informs ThePEG about the
	* base class of FxFxFileReader.
	*/
	template <>
	struct BaseClassTrait<FxFxFileReader,1>: public ClassTraitsType {
	/** Typedef of the base class of FxFxFileReader. */
	typedef FxFxReader NthBase;
	};

	/**
	* This template specialization informs ThePEG about the name of the
	* FxFxFileReader class and the shared object where it is
	* defined.
	*/
	template <>
	struct ClassTraits<FxFxFileReader>
	: public ClassTraitsBase<FxFxFileReader> {
	/**
	* Return the class name.
	*/
	static string className() { return "Herwig::FxFxFileReader"; }
	/**
	* Return the name of the shared library to be loaded to get access
	* to the FxFxFileReader class and every other class it uses
	* (except the base class).
	*/
	- static string library() { return "FxFx.so"; }
	+ static string library() { return "HwFxFx.so"; }

	};

	/** @endcond */

	}

	#endif /* THEPEG_FxFxFileReader_H */
	diff --git a/MatrixElement/FxFx/FxFxHandler.h b/MatrixElement/FxFx/FxFxHandler.h
	--- a/MatrixElement/FxFx/FxFxHandler.h
	+++ b/MatrixElement/FxFx/FxFxHandler.h
	@@ -1,658 +1,658 @@
	// -- C++ --
	#ifndef HERWIG_FxFxHandler_H
	#define HERWIG_FxFxHandler_H
	//
	// This is the declaration of the FxFxHandler class.
	//

	#include "Herwig/Shower/QTilde/QTildeShowerHandler.h"
	#include "Herwig/Shower/ShowerHandler.h"
	#include "ThePEG/Config/Pointers.h"
	#include "Herwig/Shower/ShowerAlpha.h"
	#include "fastjet/PseudoJet.hh"
	#include "fastjet/ClusterSequence.hh"
	#include "ThePEG/Utilities/CompSelector.h"
	#include "ThePEG/Utilities/XSecStat.h"

	namespace Herwig {
	class FxFxHandler;
	}

	//declaration of thepeg ptr
	namespace ThePEG {
	ThePEG_DECLARE_POINTERS(Herwig::FxFxHandler,FxFxHandlerPtr);
	}

	namespace Herwig {

	using namespace ThePEG;

	typedef vector< string > split_vector_type;

	/**
	* Here is the documentation of the FxFxHandler class.
	*
	* @see \ref FxFxHandlerInterfaces "The interfaces"
	* defined for FxFxHandler.
	*/
	class FxFxHandler: public QTildeShowerHandler {

	/**
	* FxFxHandler should have access to our private parts.
	*/
	friend class FxFxEventHandler;

	friend class FxFxReader;


	public:

	/**
	* The default constructor.
	*/
	FxFxHandler();

	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 Standard Interfaced functions. */
	//@{
	/**
	* Finalize the object
	*/
	virtual void dofinish();

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

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

	public:
	/**
	* Hook to allow vetoing of event after showering hard sub-process
	* as in e.g. MLM merging.
	*/
	virtual bool showerHardProcessVeto() const;

	/**
	* information for FxFx merging
	*/
	mutable int npLO_;
	mutable int npNLO_;

	/**
	* information for tree-level merging
	*/
	mutable vector<double> ptclust_;

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

	private:

	/*
	* whether a heavy quark has been found in the merging
	*/
	mutable bool hvqfound = false;

	/*
	* Run MLM jet-parton matching on the 'extra' jets.
	*/
	bool lightJetPartonVeto();

	/*
	* Function that calculates deltaR between a parton and a jet
	*/
	double partonJetDeltaR(ThePEG::tPPtr partonptr, LorentzMomentum jetmom) const;


	/*
	* Function that calculates deltaR between two jets
	*/
	double partonJetDeltaR(LorentzMomentum jetmom1, LorentzMomentum jetmom2) const;

	/**
	* Find jets using the FastJet package on particlesToCluster_.
	*/
	void getFastJets(double rjet, Energy ejcut, double etajcut) const;

	/**
	* Find jets using the FastJet package on particlesToCluster_.
	*/
	void getFastJetsToMatch(double rjet) const;

	/**
	* Deletes particles from partonsToMatch_ and particlesToCluster_
	* vectors so that these contain only the partons to match to the
	* jets and the particles used to build jets respectively. By and
	* large the candidates for deletion are: vector bosons and their
	* decay products, Higgs bosons, photons as well as _primary_, i.e.
	* present in the lowest multiplicity process, heavy quarks and
	* any related decay products.
	*/
	void caldel_m() const;

	/**
	* Deletes particles from partonsToMatch_ and particlesToCluster_
	* vectors so that these contain only the partons to match to the
	* jets and the particles used to build jets respectively. The candidates
	* are chosen according to the information passed from madgraph.
	*/
	void caldel_mg() const;

	/**
	* c++ translation of subroutine of same name from alpsho.f.
	* Label all particles with status between ISTLO and ISTHI
	* (until a particle with status ISTOP is found) as final-state,
	* call calsim_m and then put labels back to normal. This
	* version keeps only all IST=1 particles rejected by caldel as
	* daughters of vetoed heavy-quark mothers: jets complementary
	* to those reconstructed by caldel.
	*/
	void caldel_hvq() const;

	/**
	* get the MG5_aMC information required for FxFx merging
	*/
	void getnpFxFx() const;

	/**
	* get the MG5_aMC information required for FxFx merging
	*/
	void getECOM() const;


	/**
	* get the MG5_aMC information required for tree-level merging
	*/
	void getptclust() const;

	/**
	* Erases all occurences of a substring from a string
	*/

	void erase_substr(std::string& subject, const std::string& search) const;


	/**
	* Get the particles from lastXCombPtr filling the pair
	* preshowerISPs_ and particle pointer vector preshowerFSPs_.
	*/
	void getPreshowerParticles() const;

	/**
	* Get the particles from eventHandler()->currentEvent()->...
	* filling the particle pairs showeredISHs_, showeredISPs_,
	* showeredRems_ and the particle pointer vector showeredFSPs_.
	*/
	void getShoweredParticles() const;

	/**
	* Allows printing of debug output and sanity checks like
	* total momentum consrvation to be carried out.
	* debugLevel = -1, 0, ...5
	* = no debugging, minimal debugging, ... verbose.
	*/
	void doSanityChecks(int debugLevel) const;

	/**
	* Given a pointer to a particle this finds all its final state
	* descendents.
	*/
	void getDescendents(PPtr theParticle) const;

	/**
	* Accumulates all descendents of tops down to the b and W
	* but not including them.
	*/
	void getTopRadiation(PPtr theParticle) const;

	/**
	* Sorts a given vector of particles by descending pT or ETJET
	*/

	ParticleVector pTsort(ParticleVector unsortedVec);
	pair< vector<Energy>, vector<Lorentz5Momentum> > ETsort(vector<Energy> unsortedetjet, vector<Lorentz5Momentum> unsortedVec);

	/*
	* A function that prints a vector of Lorentz5Momenta in a fancy way
	*/
	void printMomVec(vector<Lorentz5Momentum> momVec);


	/*
	* A probability function for varying etclus_ about the mean value
	*/
	Energy etclusran_(double petc) const;

	private:

	/**
	* The static object used to initialize the description of this class.
	* Indicates that this is a concrete class with persistent data.
	*/
	static ClassDescription<FxFxHandler> initFxFxHandler;

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

	private:


	/**
	* Initial-state incoming partons prior to showering
	* (i.e. from lastXCombPtr).
	*/
	mutable PPair preshowerISPs_;

	/**
	* Final-state outgoing partICLEs prior to showering
	* (i.e. from lastXCombPtr).
	*/
	mutable ParticleVector preshowerFSPs_;

	/**
	* Final-state outgoing partICLEs prior to showering _to_be_removed_
	* from preShowerFSPs_ prior to the light-parton-light-jet matching
	* step. This same list is the starting point for determining
	* partonsToMatch_ for the case of merging in heavy quark production.
	*/
	mutable ParticleVector preshowerFSPsToDelete_;

	/**
	* Initial-state incoming hadrons after shower of hard process
	* (eventHandler()->currentEvent()->incoming()).
	*/
	mutable PPair showeredISHs_;

	/**
	* Initial-state incoming partons after shower of hard process
	* (look for partonic children of showeredISHs_).
	*/
	mutable PPair showeredISPs_;

	/**
	* Final-state outgoing partICLEs after shower of hard process
	* (eventHandler()->currentEvent()->getFinalState()).
	*/
	mutable tPVector showeredFSPs_;

	/**
	* Final-state outgoing partICLEs after shower of hard process
	* _to_be_removed_ from showeredFSPs_ prior to the
	* light-parton-light-jet matching step. This same list is the
	* starting point for determining particlesToCluster_ for the
	* case of merging in heavy quark production.
	*/
	mutable ParticleVector showeredFSPsToDelete_;

	/**
	* ONLY the final-state partons from preshowerFSPs_ that are
	* supposed to enter the jet-parton matching.
	*/
	mutable ParticleVector partonsToMatch_;

	/*
	* The shower progenitors
	*/

	mutable PPtr theProgenitor;
	mutable PPtr theLastProgenitor;

	/**
	* ONLY the final-state particles from showeredFSPs_ (and maybe
	* also showeredRems_) that are supposed to go for jet clustering.
	*/
	mutable tPVector particlesToCluster_;

	/**
	* Final-state remnants after shower of hard process
	* (look for remnants initially in showeredFSPs_).
	*/
	mutable PPair showeredRems_;

	/**
	* the COM of the incoming hadrons
	*/

	mutable double ECOM_;

	/**
	* Pointer to the object calculating the strong coupling
	*/
	ShowerAlphaPtr alphaS_;

	/**
	* Information extracted from the XComb object
	*/
	//@{
	/**
	* The fixed factorization scale used in the MEs.
	*/
	Energy pdfScale_;

	/**
	* Centre of mass energy
	*/
	Energy2 sHat_;

	/**
	* Constant alphaS used to generate LH events - if not already
	* using CKKW scale (ickkw = 1 in AlpGen for example).
	*/
	double alphaSME_;
	//@}

	/*
	* Number of rapidity segments of the calorimeter.
	*/
	unsigned int ncy_;

	/*
	* Number of phi segments of the calorimeter.
	*/
	unsigned int ncphi_;

	/*
	* Heavy flavour in WQQ,ZQQ,2Q etc (4=c, 5=b, 6=t).
	*/
	int ihvy_;

	/*
	* Number of photons in the AlpGen process.
	*/
	int nph_;

	/*
	* Number of higgses in the AlpGen process.
	*/
	int nh_;

	/*
	* Jet ET cut to apply in jet clustering (in merging).
	*/
	mutable Energy etclus_;



	/*
	* The merging mode (FxFx vs tree-level) used.
	*/
	int mergemode_;



	/*
	* Allows the vetoing on heavy quark decay products to be turned off.
	*/
	bool vetoHeavyQ_;

	/*
	* Allows vetoing of heavy flavour
	*/

	bool vetoHeavyFlavour_;


	/*
	* Mean Jet ET cut to apply in jet clustering (in merging).
	*/
	Energy etclusmean_;


	/*
	* The jet algorithm used for parton-jet matching in the MLM procedure.
	*/
	int jetAlgorithm_;

	/*
	* Allows the vetoing to be turned off completely - just for convenience.
	*/
	bool vetoIsTurnedOff_;

	/*
	* Veto if there exist softer unmatched jets than matched
	*/

	bool vetoSoftThanMatched_;

	/*
	* This flags whether the etclus_ (merging scale) should be fixed or variable according to a prob. distribution around the mean
	*/
	bool etclusfixed_;



	/*
	* maximum deviation from mean Jet ET cut to apply in jet clustering (in merging).
	*/
	Energy epsetclus_;



	/*
	* Cone size used in jet clustering (in merging).
	*/
	double rclus_;

	/*
	* Max \|eta\| for jets in clustering (in merging).
	*/
	double etaclmax_;

	/*
	* Default 1.5 factor used to decide if a jet matches a parton
	* in merging: if DR(parton,jet)<rclusfactor*rclus the parton
	* and jet are said to have been matched.
	*/
	double rclusfactor_;

	/*
	* Determines whether to detect the hard process or to manually determine which particles
	* to include in the merging. If False, then the ihrd code below is used.
	*/
	bool hpdetect_;

	/*
	* The AlpGen hard process code. Relation to the AlpGen process names:
	* 1: wqq, 2: zqq, 3: wjet, 4: zjet, 5: vbjet, 6: 2Q, 8: QQh, 9: Njet,
	* 10: wcjet, 11: phjet, 12: hjet, 13: top, 14: wphjet, 15: wphqq,
	* 16: 2Qph.
	*/
	int ihrd_;

	/*
	* The number of light jets in the AlpGen process (i.e. the 'extra' ones).
	*/
	int njets_;

	/*
	* Mimimum parton-parton R-sep used for generation (used for hvq merging).
	*/
	double drjmin_;

	/*
	* This flags that the highest multiplicity ME-level process is
	* being processed.
	*/
	mutable bool highestMultiplicity_;

	/*
	* The forwards rapidity span of the calorimeter.
	*/
	double ycmax_;


	/*
	* The backwards rapidity span of the calorimeter.
	*/
	double ycmin_;












	/*
	* Cosine of phi values of calorimeter cell centres.
	* Goes phi~=0 to phi~=2*pi (index = 0 ---> ncphi).
	* ==> Cosine goes from +1 ---> +1 (index = 0 ---> ncphi).
	*/
	vector<double> cphcal_;

	/*
	* Sine of phi values of calorimeter cell centres.
	* Goes phi~=0 to phi~=2*pi (index = 0 ---> ncphi).
	* ==> Sine goes 0 -> 1 -> 0 -> -1 -> 0 (index = 0 ---> ncphi).
	*/
	vector<double> sphcal_;

	/*
	* Cosine of theta values of calorimeter cell centres in Y.
	* Goes bwds th~=pi to fwds th~=0 (index = 0 ---> ncy).
	* ==> Cosine goes from -1 ---> +1 (index = 0 ---> ncy).
	*/
	vector<double> cthcal_;

	/*
	* Sine of theta values of calorimeter cell centres in Y.
	* Goes bwds th~=pi to fwds th~=0 (index = 0 ---> ncy).
	* ==> Sine goes from 0 ---> +1 ---> 0 (index = 0 ---> ncy).
	*/
	vector<double> sthcal_;

	/*
	* Transverse energy deposit in a given calorimeter cell.
	* First array index corresponds to rapidity index of cell,
	* second array index corresponds to phi cell index.
	*/
	vector<vector<Energy> > et_;

	/*
	* For a given calorimeter cell this holds the index of the jet
	* that the cell was clustered into.
	*/
	vector<vector<int> > jetIdx_;

	/*
	* Vector holding the Lorentz 5 momenta of each jet.
	*/
	mutable vector<Lorentz5Momentum> pjet_;

	/*
	* Vector holding the Lorentz 5 momenta of each jet from ME partons
	*/
	mutable vector<Lorentz5Momentum> pjetME_;


	/*
	* Vector holding the list of FS particles resulting from
	* the particle input to getDescendents.
	*/
	mutable ParticleVector tmpList_;

	/*
	* Variables for the C++ translation of the calini_m(), calsim_m(),
	* getjet_m(...) and caldel_m() functions
	*/
	mutable vector<Energy> etjet_;
	vector<Energy> etjetME_;
	mutable double dely_, delphi_;

	};

	}

	#include "ThePEG/Utilities/ClassTraits.h"

	namespace ThePEG {

	/** @cond TRAITSPECIALIZATIONS */

	/** This template specialization informs ThePEG about the
	* base classes of FxFxHandler. */
	template <>
	struct BaseClassTrait<Herwig::FxFxHandler,1> {
	/** Typedef of the first base class of FxFxHandler. */
	typedef Herwig::QTildeShowerHandler NthBase;
	};

	/** This template specialization informs ThePEG about the name of
	* the FxFxHandler class and the shared object where it is defined. */
	template <>
	struct ClassTraits<Herwig::FxFxHandler>
	: public ClassTraitsBase<Herwig::FxFxHandler> {
	/** Return a platform-independent class name */
	static string className() { return "Herwig::FxFxHandler"; }
	/**
	* The name of a file containing the dynamic library where the class
	* FxFxHandler is implemented. It may also include several, space-separated,
	* libraries if the class FxFxHandler depends on other classes (base classes
	* excepted). In this case the listed libraries will be dynamically
	* linked in the order they are specified.
	*/
	- static string library() { return "FxFxHandler.so"; }
	+ static string library() { return "HwFxFxHandler.so"; }
	};

	/** @endcond */

	}

	#endif /* HERWIG_FxFxHandler_H */
	diff --git a/MatrixElement/FxFx/FxFxReader.h b/MatrixElement/FxFx/FxFxReader.h
	--- a/MatrixElement/FxFx/FxFxReader.h
	+++ b/MatrixElement/FxFx/FxFxReader.h
	@@ -1,1006 +1,1006 @@
	// -- C++ --
	//
	// FxFxReader.h is a part of ThePEG - Toolkit for HEP Event Generation
	// Copyright (C) 1999-2011 Leif Lonnblad
	//
	// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
	// Please respect the MCnet academic guidelines, see GUIDELINES for details.
	//
	#ifndef THEPEG_FxFxReader_H
	#define THEPEG_FxFxReader_H
	// This is the declaration of the FxFxReader class.

	#include "FxFx.h"
	#include "ThePEG/Handlers/HandlerBase.h"
	#include "ThePEG/Utilities/ObjectIndexer.h"
	#include "ThePEG/Utilities/Exception.h"
	#include "ThePEG/Utilities/XSecStat.h"
	#include "ThePEG/PDF/PartonBinInstance.h"
	#include "ThePEG/PDF/PartonBin.fh"
	#include "ThePEG/MatrixElement/ReweightBase.h"
	#include "FxFxEventHandler.fh"
	#include "FxFxReader.fh"
	#include "ThePEG/Utilities/CFile.h"
	#include <cstdio>
	#include <cstring>

	namespace ThePEG {

	/**
	* FxFxReader is an abstract base class to be used for objects
	* which reads event files or streams from matrix element
	* generators. Derived classes must at least implement the open() and
	* doReadEvent() methods to read in information about the whole run into
	* the HEPRUP variable and next event into the HEPEUP variable
	* respectively. Also the close() function to close the file or stream
	* read must be implemented. Although these functions are named as if
	* we are reading from event files, they could just as well implement
	* the actual generation of events.
	*
	* After filling the HEPRUP and HEPEUP variables, which are protected
	* and easily accesible from the sub-class, this base class will then
	* be responsible for transforming this data to the ThePEG Event
	* record in the getEvent() method. <code>FxFxReader</code>s can
	* only be used inside FxFxEventHandler objects.
	*
	* In the initialization the virtual open() and scan() functions are
	* called. Here the derived class must provide the information about
	* the processes in the variables corresponding to the HEPRUP common
	* block. Note that the IDWTUP is required to be +/- 1, and sub
	* classes are required to change the information accordingly to
	* ensure the correct corss section sampling. Note also that the
	* controlling FxFxEventHandler may choose to generate weighted
	* events even if IDWTUP is 1.
	*
	* Note that the information given per process in e.g. the XSECUP and
	* XMAXUP vectors is not used by the FxFxEventHandler and by
	* default the FxFxReader is not assumed to be able to actively
	* choose between the sub-processes. Instead, the
	* FxFxEventHandler can handle several FxFxReader objects
	* and choose between them. However, a sub-class of FxFxReader
	* may set the flag isActive, in which case it is assumed to be able
	* to select between its sub-processes itself.
	*
	* The FxFxReader may be assigned a number ReweightBase objects
	* which either completely reweights the events produced (in the
	* reweights vector), or only biases the selection without influencing
	* the cross section (in the preweights vector). Note that it is the
	* responsibility of a sub-class to call the reweight() function and
	* multiply the weight according to its return value (typically done
	* in the readEvent() function).
	*
	* @see \ref FxFxReaderInterfaces "The interfaces"
	* defined for FxFxReader.
	* @see Event
	* @see FxFxEventHandler
	*/
	class FxFxReader: public HandlerBase, public LastXCombInfo<> {

	/**
	* FxFxEventHandler should have access to our private parts.
	*/
	friend class FxFxEventHandler;

	/**
	* Map for accumulating statistics of cross sections per process
	* number.
	*/
	typedef map<int,XSecStat> StatMap;

	/**
	* Map of XComb objects describing the incoming partons indexed by
	* the corresponding PartonBin pair.
	*/
	typedef map<tcPBPair,XCombPtr> XCombMap;

	/**
	* A vector of pointers to ReweightBase objects.
	*/
	typedef vector<ReweightPtr> ReweightVector;

	public:

	/** @name Standard constructors and destructors. */
	//@{
	/**
	* Default constructor. If the optional argument is true, the reader
	* is assumed to be able to produce events on demand for a given
	* process.
	*/
	FxFxReader(bool active = false);

	/**
	* Copy-constructor.
	*/
	FxFxReader(const FxFxReader &);

	/**
	* Destructor.
	*/
	virtual ~FxFxReader();
	//@}

	public:

	/** @name Main virtual fuctions to be overridden in
	* sub-classes. They are named as if we are reading from event
	* files, but could equally well implement the actual generation of
	* events. */
	//@{
	/**
	* Open a file or stream with events and read in the run information
	* into the heprup variable.
	*/
	virtual void open() = 0;

	/**
	* Read the next event from the file or stream into the
	* corresponding protected variables. Return false if there is no
	* more events.
	*/
	virtual bool doReadEvent() = 0;

	/**
	* Close the file or stream from which events have been read.
	*/
	virtual void close() = 0;

	/**
	* return the weight names
	*/
	// virtual vector<string> optWeightsNamesFunc();
	virtual vector<string> optWeightsNamesFunc() = 0;
	//virtual vector<string*> optWeightNamesFunc() = 0;
	vector<string> optionalWeightsNames;

	/**
	* The ID (e.g. 100x, 2001) for the weight
	*/

	// vector<string> optionalWeightsNames;


	//@}

	/** @name Other important function which may be overridden in
	* sub-classes which wants to bypass the basic HEPRUP or HEPEUP
	* variables or otherwise facilitate the conversion to ThePEG
	* objects. */
	//@{
	/**
	* Initialize. This function is called by the FxFxEventHandler
	* to which this object is assigned.
	*/
	virtual void initialize(FxFxEventHandler & eh);

	/**
	* Calls readEvent() or uncacheEvent() to read information into the
	* FxFx common block variables. This function is called by the
	* FxFxEventHandler if this reader has been selectod to
	* produce an event.
	*
	* @return the weight asociated with this event. If negative weights
	* are allowed it should be between -1 and 1, otherwise between 0
	* and 1. If outside these limits the previously estimated maximum
	* is violated. Note that the estimated maximum then should be
	* updated from the outside.
	*/
	virtual double getEvent();

	/**
	* Calls doReadEvent() and performs pre-defined reweightings. A
	* sub-class overrides this function it must make sure that the
	* corresponding reweightings are done.
	*/
	virtual bool readEvent();

	/**
	* Skip \a n events. Used by FxFxEventHandler to make sure
	* that a file is scanned an even number of times in case the events
	* are not ramdomly distributed in the file.
	*/
	virtual void skip(long n);

	/**
	* Get an XComb object. Converts the information in the Les Houches
	* common block variables to an XComb object describing the sub
	* process. This is the way information is conveyed from the reader
	* to the controlling FxFxEventHandler.
	*/
	tXCombPtr getXComb();

	/**
	* Get a SubProcess object corresponding to the information in the
	* Les Houches common block variables.
	*/
	tSubProPtr getSubProcess();

	/**
	* Scan the file or stream to obtain information about cross section
	* weights and particles etc. This function should fill the
	* variables corresponding to the /HEPRUP/ common block. The
	* function returns the number of events scanned.
	*/
	virtual long scan();

	/**
	* Take the information corresponding to the HEPRUP common block and
	* initialize the statistics for this reader.
	*/
	virtual void initStat();

	/**
	* Reweights the current event using the reweights and preweights
	* vectors. It is the responsibility of the sub-class to call this
	* function after the HEPEUP information has been retrieved.
	*/
	double reweight();

	/**
	* Converts the information in the Les Houches common block
	* variables into a Particle objects.
	*/
	virtual void fillEvent();

	/**
	* Removes the particles created in the last generated event,
	* preparing to produce a new one.
	*/
	void reset();

	/**
	* Possibility for subclasses to recover from non-conformant
	* settings of XMAXUP when an event file has been scanned with \a
	* neve events. Should set weightScale so that the average XMAXUP
	* times weightScale gives the cross section for a process. (This is
	* needed for MadEvent).
	*/
	virtual void setWeightScale(long neve);

	//@}

	/** @name Access information about the current event. */
	//@{

	/**
	* Return the size of this event in bytes. To be used for the cache
	* file. \a npart is the number of particles. If \a npart is 0, the
	* number is taken from NUP.
	*/
	static size_t eventSize(int N) {
	return (N + 1)*sizeof(int) + // IDPRUP, ISTUP
	(7N + 4)sizeof(double) + // XWGTUP, SCALUP, AQEDUP, AQCDUP, PUP,
	// VTIMUP, SPINUP
	N*sizeof(long) + // IDUP
	2Nsizeof(pair<int,int>) + // MOTHUP, ICOLUP
	sizeof(pair<double,double>) + // XPDWUP.
	2*sizeof(double); // lastweight and preweight
	}

	/**
	* The current event weight given by XWGTUP times possible
	* reweighting. Note that this is not necessarily the same as what
	* is returned by getEvent(), which is scaled with the maximum
	* weight.
	*/
	double eventWeight() const { return hepeup.XWGTUP*lastweight; }

	/**
	* Return the optional named weights associated to the current event.
	*/
	const map<string,double>& optionalEventWeights() const { return optionalWeights; }

	/**
	* Return the optional npLO and npNLO
	*/
	const int& optionalEventnpLO() const { return optionalnpLO; }
	const int& optionalEventnpNLO() const { return optionalnpNLO; }

	/**
	* The pair of PartonBinInstance objects describing the current
	* incoming partons in the event.
	*/
	const PBIPair & partonBinInstances() const { return thePartonBinInstances; }
	/**
	* Return the instances of the beam particles for the current event.
	*/
	const PPair & beams() const { return theBeams; }
	/**
	* Return the instances of the incoming particles to the sub process
	* for the current event.
	*/
	const PPair & incoming() const { return theIncoming; }
	/**
	* Return the instances of the outgoing particles from the sub process
	* for the current event.
	*/
	const PVector & outgoing() const { return theOutgoing; }
	/**
	* Return the instances of the intermediate particles in the sub
	* process for the current event.
	*/
	const PVector & intermediates() const { return theIntermediates; }
	/**
	* If this reader is to be used (possibly together with others) for
	* CKKW reweighting and veto, this should give the multiplicity of
	* outgoing particles in the highest multiplicity matrix element in
	* the group.
	*/
	int maxMultCKKW() const { return theMaxMultCKKW; }
	/**
	* If this reader is to be used (possibly together with others) for
	* CKKW reweighting and veto, this should give the multiplicity of
	* outgoing particles in the lowest multiplicity matrix element in
	* the group.
	*/
	int minMultCKKW() const { return theMinMultCKKW; } //@}

	/** @name Other inlined access functions. */
	//@{
	/**
	* The number of events found in this reader. If less than zero the
	* number of events are unlimited.
	*/
	long NEvents() const { return theNEvents; }

	/**
	* The number of events produced so far. Is reset to zero if an
	* event file is reopened.
	*/
	long currentPosition() const { return position; }

	/**
	* The maximum number of events to scan to collect information about
	* processes and cross sections. If less than 0, all events will be
	* scanned.
	*/
	long maxScan() const { return theMaxScan; }

	/**
	* Return true if this reader is active.
	*/
	bool active() const { return isActive; }

	/**
	* True if negative weights may be produced.
	*/
	bool negativeWeights() const { return heprup.IDWTUP < 0; }

	/**
	* The collected cross section statistics for this reader.
	*/
	const XSecStat & xSecStats() const { return stats; }

	/**
	* Collected statistics about the individual processes.
	*/
	const StatMap & processStats() const { return statmap; }

	/**
	* Select the current event. It will later be rejected with a
	* probability given by \a weight.
	*/
	void select(double weight) {
	stats.select(weight);
	statmap[hepeup.IDPRUP].select(weight);
	}

	/**
	* Accept the current event assuming it was previously selcted.
	*/
	void accept() {
	stats.accept();
	statmap[hepeup.IDPRUP].accept();
	}

	/**
	* Reject the current event assuming it was previously accepted.
	*/
	void reject(double w) {
	stats.reject(w);
	statmap[hepeup.IDPRUP].reject(w);
	}

	/**
	* Increase the overestimated cross section for this reader.
	*/
	virtual void increaseMaxXSec(CrossSection maxxsec);

	/**
	* The PartonExtractor object used to construct remnants.
	*/
	tPExtrPtr partonExtractor() const { return thePartonExtractor; }

	/**
	* Return a possibly null pointer to a CascadeHandler to be used for
	* CKKW-reweighting.
	*/
	tCascHdlPtr CKKWHandler() const { return theCKKW; }

	/**
	* The pairs of PartonBin objects describing the partons which can
	* be extracted by the PartonExtractor object.
	*/
	const PartonPairVec & partonBins() const { return thePartonBins; }

	/**
	* The map of XComb objects indexed by the corresponding PartonBin
	* pair.
	*/
	const XCombMap & xCombs() const { return theXCombs; }

	/**
	* The Cuts object to be used for this reader.
	*/
	const Cuts & cuts() const { return *theCuts; }

	//@}

	protected:

	/** @name Functions for manipulating cache files. */
	//@{

	/**
	* Name of file used to cache the events form the reader in a
	* fast-readable form. If empty, no cache file will be generated.
	*/
	string cacheFileName() const { return theCacheFileName; }

	/**
	* Determines whether to apply cuts to events converting them to
	* ThePEG format.
	*/
	bool cutEarly() const { return doCutEarly; }

	/**
	* File stream for the cache.
	*/
	CFile cacheFile() const { return theCacheFile;}

	/**
	* Open the cache file for reading.
	*/
	void openReadCacheFile();

	/**
	* Open the cache file for writing.
	*/
	void openWriteCacheFile();

	/**
	* Close the cache file;
	*/
	void closeCacheFile();

	/**
	* Write the current event to the cache file.
	*/
	void cacheEvent() const;

	/**
	* Read an event from the cache file. Return false if something went wrong.
	*/
	bool uncacheEvent();

	/**
	* Reopen a reader. If we have reached the end of an event file,
	* reopen it and issue a warning if we have used up a large fraction
	* of it.
	*/
	void reopen();

	/**
	* Helper function to write a variable to a memory location
	*/
	template <typename T>
	static char * mwrite(char * pos, const T & t, size_t n = 1) {
	std::memcpy(pos, &t, n*sizeof(T));
	return pos + n*sizeof(T);
	}

	/**
	* Helper function to read a variable from a memory location
	*/
	template <typename T>
	static const char * mread(const char * pos, T & t, size_t n = 1) {
	std::memcpy(&t, pos, n*sizeof(T));
	return pos + n*sizeof(T);
	}

	//@}

	/** @name Auxilliary virtual methods which may be verridden by sub-classes. */
	//@{
	/**
	* Check the existence of a pair of PartonBin objects corresponding
	* to the current event.
	*
	* @return false if no pair of suitable PartonBin objects was found.
	*/
	virtual bool checkPartonBin();

	/**
	* Create instances of all particles in the event and store them
	* in particleIndex.
	*/
	virtual void createParticles();

	/**
	* Using the already created particles create a pair of
	* PartonBinInstance objects corresponding to the incoming
	* partons. Return the corresponding PartonBin objects.
	*/
	virtual tcPBPair createPartonBinInstances();

	/**
	* Create instances of the incoming beams in the event and store
	* them in particleIndex. If no beam particles are included in the
	* event they are created from the run info.
	*/
	virtual void createBeams();

	/**
	* Go through the mother indices and connect up the Particles.
	*/
	virtual void connectMothers();
	//@}

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

	/**
	* Standard Init function used to initialize the interfaces.
	*/
	static void Init();

	protected:

	/** @name Set functions for some variables not in the Les Houches accord. */
	//@{
	/**
	* The number of events in this reader. If less than zero the number
	* of events is unlimited.
	*/
	void NEvents(long x) { theNEvents = x; }

	/**
	* The map of XComb objects indexed by the corresponding PartonBin
	* pair.
	*/
	XCombMap & xCombs() { return theXCombs; }
	//@}

	/** @name Standard (and non-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();

	/**
	* 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() {
	close();
	HandlerBase::dofinish();
	}

	/**
	* Return true if this object needs to be initialized before all
	* other objects because it needs to extract PDFs from the event file.
	*/
	virtual bool preInitialize() const;

	/**
	* Called from doinit() to extract PDFs from the event file and add
	* the corresponding objects to the current EventGenerator.
	*/
	virtual void initPDFs();
	//@}

	protected:

	/**
	* The HEPRUP common block.
	*/
	HEPRUP heprup;

	/**
	* The HEPEUP common block.
	*/
	HEPEUP hepeup;

	/**
	* The ParticleData objects corresponding to the incoming particles.
	*/
	tcPDPair inData;

	/**
	* The PDFBase objects which has been used for the beam particle
	* when generating the events being read. Specified in the interface
	* or derived from PDFGUP and PDFSUP.
	*/
	pair<PDFPtr,PDFPtr> inPDF;

	/**
	* The PDFBase object to be used in the subsequent generation.
	*/
	pair<cPDFPtr,cPDFPtr> outPDF;

	/**
	* The PartonExtractor object used to construct remnants.
	*/
	PExtrPtr thePartonExtractor;

	/**
	* A pointer to a CascadeHandler to be used for CKKW-reweighting.
	*/
	tCascHdlPtr theCKKW;

	/**
	* The pairs of PartonBin objects describing the partons which can
	* be extracted by the PartonExtractor object.
	*/
	PartonPairVec thePartonBins;

	/**
	* The map of XComb objects indexed by the corresponding PartonBin
	* pair.
	*/
	XCombMap theXCombs;

	/**
	* The Cuts object to be used for this reader.
	*/
	CutsPtr theCuts;

	/**
	* The number of events in this reader. If less than zero the number
	* of events is unlimited.
	*/
	long theNEvents;

	/**
	* The number of events produced by this reader so far. Is reset
	* every time an event file is reopened.
	*/
	long position;

	/**
	* The number of times this reader has been reopened.
	*/
	int reopened;

	/**
	* The maximum number of events to scan to collect information about
	* processes and cross sections. If less than 0, all events will be
	* scanned.
	*/
	long theMaxScan;

	/**
	* Flag to tell whether we are in the process of scanning.
	*/
	bool scanning;

	/**
	* True if this is an active reader.
	*/
	bool isActive;

	/**
	* Name of file used to cache the events form the reader in a
	* fast-readable form. If empty, no cache file will be generated.
	*/
	string theCacheFileName;

	/**
	* Determines whether to apply cuts to events before converting them
	* to ThePEG format.
	*/
	bool doCutEarly;

	/**
	* Collect statistics for this reader.
	*/
	XSecStat stats;

	/**
	* Collect statistics for each individual process.
	*/
	StatMap statmap;

	/**
	* The pair of PartonBinInstance objects describing the current
	* incoming partons in the event.
	*/
	PBIPair thePartonBinInstances;

	/**
	* Association between ColourLines and colour indices in the current
	* translation.
	*/
	ObjectIndexer<long,ColourLine> colourIndex;

	/**
	* Association between Particles and indices in the current
	* translation.
	*/
	ObjectIndexer<long,Particle> particleIndex;

	/**
	* The instances of the beam particles for the current event.
	*/
	PPair theBeams;

	/**
	* The instances of the incoming particles to the sub process for
	* the current event.
	*/
	PPair theIncoming;

	/**
	* The instances of the outgoing particles from the sub process for
	* the current event.
	*/
	PVector theOutgoing;

	/**
	* The instances of the intermediate particles in the sub process for
	* the current event.
	*/
	PVector theIntermediates;

	/**
	* File stream for the cache.
	*/
	CFile theCacheFile;

	/**
	* The reweight objects modifying the weights of this reader.
	*/
	ReweightVector reweights;

	/**
	* The preweight objects modifying the weights of this reader.
	*/
	ReweightVector preweights;

	/**
	* The factor with which this reader was last pre-weighted.
	*/
	double preweight;

	/**
	* Should the event be reweighted by PDFs used by the PartonExtractor?
	*/
	bool reweightPDF;

	/**
	* Should PDFBase objects be constructed from the information in the
	* event file in the initialization?
	*/
	bool doInitPDFs;

	/**
	* If this reader is to be used (possibly together with others) for
	* CKKW reweighting and veto, this should give the multiplicity of
	* outgoing particles in the highest multiplicity matrix element in
	* the group.
	*/
	int theMaxMultCKKW;

	/**
	* If this reader is to be used (possibly together with others) for
	* CKKW reweighting and veto, this should give the multiplicity of
	* outgoing particles in the lowest multiplicity matrix element in
	* the group.
	*/
	int theMinMultCKKW;

	/**
	* The weight multiplying the last read event due to PDF
	* reweighting, CKKW reweighting or assigned reweight and preweight
	* objects.
	*/
	double lastweight;

	/**
	* The optional weights associated to the last read events.
	*/
	map<string,double> optionalWeights;

	/**
	* If the maximum cross section of this reader has been increased
	* with increaseMaxXSec(), this is the total factor with which it
	* has been increased.
	*/
	double maxFactor;

	/**
	* npLO for FxFx merging
	*/
	int optionalnpLO;

	/**
	* npNLO for FxFx merging
	*/
	int optionalnpNLO;

	/**
	* The (reweighted) XWGTUP value should be scaled with this cross
	* section when compared to the overestimated cross section.
	*/
	CrossSection weightScale;

	/**
	* Individual scales for different sub-processes if reweighted.
	*/
	vector<double> xSecWeights;

	/**
	* Individual maximum weights for individual (possibly reweighted)
	* processes.
	*/
	map<int,double> maxWeights;

	/**
	* Is set to true when getEvent() is called from skip(int).
	*/
	bool skipping;

	/**
	* Option for the treatment of the momenta supplied
	*/
	unsigned int theMomentumTreatment;

	/**
	* Set to true if warnings about possible weight incompatibilities
	* should be issued.
	*/
	bool useWeightWarnings;

	/**
	* Option to allow reopening of the file
	*/
	bool theReOpenAllowed;

	/**
	* Use the spin information
	*/
	bool theIncludeSpin;

	private:

	/** Access function for the interface. */
	void setBeamA(long id);
	/** Access function for the interface. */
	long getBeamA() const;
	/** Access function for the interface. */
	void setBeamB(long id);
	/** Access function for the interface. */
	long getBeamB() const;
	/** Access function for the interface. */
	void setEBeamA(Energy e);
	/** Access function for the interface. */
	Energy getEBeamA() const;
	/** Access function for the interface. */
	void setEBeamB(Energy e);
	/** Access function for the interface. */
	Energy getEBeamB() const;
	/** Access function for the interface. */
	void setPDFA(PDFPtr);
	/** Access function for the interface. */
	PDFPtr getPDFA() const;
	/** Access function for the interface. */
	void setPDFB(PDFPtr);
	/** Access function for the interface. */
	PDFPtr getPDFB() const;

	private:

	/**
	* Describe an abstract base class with persistent data.
	*/
	static AbstractClassDescription<FxFxReader> initFxFxReader;

	/**
	* Private and non-existent assignment operator.
	*/
	FxFxReader & operator=(const FxFxReader &) = delete;

	public:

	/** @cond EXCEPTIONCLASSES */
	/** Exception class used by FxFxReader in case inconsistencies
	* are encountered. */
	class FxFxInconsistencyError: public Exception {};

	/** Exception class used by FxFxReader in case more events
	than available are requested. */
	class FxFxReopenWarning: public Exception {};

	/** Exception class used by FxFxReader in case reopening an
	event file fails. */
	class FxFxReopenError: public Exception {};

	/** Exception class used by FxFxReader in case there is
	information missing in the initialization phase. */
	class FxFxInitError: public InitException {};
	/** @endcond */

	};

	/// Stream output for HEPEUP
	ostream & operator<<(ostream & os, const HEPEUP & h);

	}


	#include "ThePEG/Utilities/ClassTraits.h"

	namespace ThePEG {

	/** @cond TRAITSPECIALIZATIONS */

	/**
	* This template specialization informs ThePEG about the
	* base class of FxFxReader.
	*/
	template <>
	struct BaseClassTrait<FxFxReader,1>: public ClassTraitsType {
	/** Typedef of the base class of FxFxReader. */
	typedef HandlerBase NthBase;
	};

	/**
	* This template specialization informs ThePEG about the name of the
	* FxFxReader class and the shared object where it is
	* defined.
	*/
	template <>
	struct ClassTraits<FxFxReader>
	: public ClassTraitsBase<FxFxReader> {
	/**
	* Return the class name.
	*/
	static string className() { return "Herwig::FxFxReader"; }
	/**
	* Return the name of the shared library to be loaded to get access
	* to the FxFxReader class and every other class it uses
	* (except the base class).
	*/
	- static string library() { return "FxFx.so"; }
	+ static string library() { return "HwFxFx.so"; }

	};

	/** @endcond */

	}

	#endif /* THEPEG_FxFxReader_H */

File Metadata

Mime Type: text/x-diff
Expires: Tue, Nov 19, 6:33 PM (1 d, 21 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3798649
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions