No OneTemporary
Actions

Size

238 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 3869333..ae4c87f 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,67 +1,69 @@
	cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
	project(CepGen)
	set(PROJECT_VERSION 1)

	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic -g")

	#----- define all individual modules to be built beforehand

	set(MODULES core processes hadronisers physics export)

	#----- enable fortran (for Pythia/Herwig/...)

	enable_language(Fortran OPTIONAL)

	#----- include external hadronisers/...

	add_subdirectory(external)

	if(EXISTS $ENV{has_pythia6})
	add_definitions(-DPYTHIA6)
	endif()
	if(EXISTS $ENV{has_herwig})
	add_definitions(-DHERWIG)
	endif()
	if(EXISTS $ENV{has_jetset})
	add_definitions(-DJETSET)
	endif()
	if(EXISTS $ENV{has_grv})
	add_definitions(-DGRVPDF)
	endif()

	#----- build all the intermediate objects

	include_directories(${PROJECT_SOURCE_DIR})
	foreach(_module ${MODULES})
	include_directories(${PROJECT_SOURCE_DIR}/${_module})
	add_subdirectory(${_module})
	endforeach()

	#----- link everything into the executables

	add_executable(cepgen main.cpp)
	target_link_libraries(cepgen CepGenCore CepGenExternalHadronisers CepGenPhysics CepGenProcesses)

	find_package(HepMC)
	if(HEPMC_LIBRARIES)
	+ message(STATUS "HepMC found in " ${HEPMC_INCLUDE_DIR})
	add_executable(cepgen-lhe cepgen-lhe.cpp)
	- target_link_libraries(cepgen-lhe CepGenCore CepGenExternalHadronisers CepGenPhysics CepGenProcesses CepGenExporter)
	+ target_link_libraries(cepgen-lhe ${HEPMC_LIBRARIES} CepGenCore CepGenExternalHadronisers CepGenPhysics CepGenProcesses CepGenExporter)
	endif()

	#----- copy the input cards and other files

	file(GLOB input_cards RELATIVE ${PROJECT_SOURCE_DIR} cards/*)
	foreach(_files ${input_cards})
	configure_file(
	${_files}
	${_files}
	COPYONLY
	)
	endforeach()

	file(GLOB readme RELATIVE ${PROJECT_SOURCE_DIR} README)
	configure_file(${readme} ${readme} COPYONLY)

	#----- set the tests directory

	-add_subdirectory("test")
	+add_subdirectory(test)
	+add_subdirectory(utils)
	diff --git a/Doxyfile b/Doxyfile
	index ead44e5..55897c6 100644
	--- a/Doxyfile
	+++ b/Doxyfile
	@@ -1,2400 +1,2400 @@
	# Doxyfile 1.8.10

	# This file describes the settings to be used by the documentation system
	# doxygen (www.doxygen.org) for a project.
	#
	# All text after a double hash (##) is considered a comment and is placed in
	# front of the TAG it is preceding.
	#
	# All text after a single hash (#) is considered a comment and will be ignored.
	# The format is:
	# TAG = value [value, ...]
	# For lists, items can also be appended using:
	# TAG += value [value, ...]
	# Values that contain spaces should be placed between quotes (\" \").

	#---------------------------------------------------------------------------
	# Project related configuration options
	#---------------------------------------------------------------------------

	# This tag specifies the encoding used for all characters in the config file
	# that follow. The default is UTF-8 which is also the encoding used for all text
	# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
	# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
	# for the list of possible encodings.
	# The default value is: UTF-8.

	DOXYFILE_ENCODING = UTF-8

	# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
	# double-quotes, unless you are using Doxywizard) that should identify the
	# project for which the documentation is generated. This name is used in the
	# title of most generated pages and in a few other places.
	# The default value is: My Project.

	PROJECT_NAME = "CepGen"

	# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
	# could be handy for archiving the generated documentation or if some version
	# control system is used.

	PROJECT_NUMBER = "0.7"

	# Using the PROJECT_BRIEF tag one can provide an optional one line description
	# for a project that appears at the top of each page and should give viewer a
	# quick idea about the purpose of the project. Keep the description short.

	PROJECT_BRIEF = "A Monte-Carlo integrator and events generator for the simulation of central exclusive (two-photon/...) processes"

	# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
	# in the documentation. The maximum height of the logo should not exceed 55
	# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
	# the logo to the output directory.

	PROJECT_LOGO = cepgen_logo.pdf

	# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
	# into which the generated documentation will be written. If a relative path is
	# entered, it will be relative to the location where doxygen was started. If
	# left blank the current directory will be used.

	OUTPUT_DIRECTORY = doc

	# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
	# directories (in 2 levels) under the output directory of each output format and
	# will distribute the generated files over these directories. Enabling this
	# option can be useful when feeding doxygen a huge amount of source files, where
	# putting all generated files in the same directory would otherwise causes
	# performance problems for the file system.
	# The default value is: NO.

	CREATE_SUBDIRS = NO

	# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
	# characters to appear in the names of generated files. If set to NO, non-ASCII
	# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
	# U+3044.
	# The default value is: NO.

	ALLOW_UNICODE_NAMES = NO

	# The OUTPUT_LANGUAGE tag is used to specify the language in which all
	# documentation generated by doxygen is written. Doxygen will use this
	# information to generate all constant output in the proper language.
	# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
	# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
	# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
	# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
	# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
	# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
	# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
	# Ukrainian and Vietnamese.
	# The default value is: English.

	OUTPUT_LANGUAGE = English

	# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
	# descriptions after the members that are listed in the file and class
	# documentation (similar to Javadoc). Set to NO to disable this.
	# The default value is: YES.

	BRIEF_MEMBER_DESC = YES

	# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
	# description of a member or function before the detailed description
	#
	# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
	# brief descriptions will be completely suppressed.
	# The default value is: YES.

	REPEAT_BRIEF = NO

	# This tag implements a quasi-intelligent brief description abbreviator that is
	# used to form the text in various listings. Each string in this list, if found
	# as the leading text of the brief description, will be stripped from the text
	# and the result, after processing the whole list, is used as the annotated
	# text. Otherwise, the brief description is used as-is. If left blank, the
	# following values are used ($name is automatically replaced with the name of
	# the entity):The $name class, The $name widget, The $name file, is, provides,
	# specifies, contains, represents, a, an and the.

	ABBREVIATE_BRIEF =

	# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
	# doxygen will generate a detailed section even if there is only a brief
	# description.
	# The default value is: NO.

	ALWAYS_DETAILED_SEC = NO

	# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
	# inherited members of a class in the documentation of that class as if those
	# members were ordinary class members. Constructors, destructors and assignment
	# operators of the base classes will not be shown.
	# The default value is: NO.

	INLINE_INHERITED_MEMB = YES

	# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
	# before files name in the file list and in the header files. If set to NO the
	# shortest path that makes the file name unique will be used
	# The default value is: YES.

	FULL_PATH_NAMES = YES

	# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
	# Stripping is only done if one of the specified strings matches the left-hand
	# part of the path. The tag can be used to show relative paths in the file list.
	# If left blank the directory from which doxygen is run is used as the path to
	# strip.
	#
	# Note that you can specify absolute paths here, but also relative paths, which
	# will be relative from the directory where doxygen is started.
	# This tag requires that the tag FULL_PATH_NAMES is set to YES.

	STRIP_FROM_PATH =

	# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
	# path mentioned in the documentation of a class, which tells the reader which
	# header file to include in order to use a class. If left blank only the name of
	# the header file containing the class definition is used. Otherwise one should
	# specify the list of include paths that are normally passed to the compiler
	# using the -I flag.

	STRIP_FROM_INC_PATH =

	# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
	# less readable) file names. This can be useful is your file systems doesn't
	# support long names like on DOS, Mac, or CD-ROM.
	# The default value is: NO.

	SHORT_NAMES = NO

	# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
	# first line (until the first dot) of a Javadoc-style comment as the brief
	# description. If set to NO, the Javadoc-style will behave just like regular Qt-
	# style comments (thus requiring an explicit @brief command for a brief
	# description.)
	# The default value is: NO.

	JAVADOC_AUTOBRIEF = NO

	# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
	# line (until the first dot) of a Qt-style comment as the brief description. If
	# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
	# requiring an explicit \brief command for a brief description.)
	# The default value is: NO.

	QT_AUTOBRIEF = NO

	# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
	# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
	# a brief description. This used to be the default behavior. The new default is
	# to treat a multi-line C++ comment block as a detailed description. Set this
	# tag to YES if you prefer the old behavior instead.
	#
	# Note that setting this tag to YES also means that rational rose comments are
	# not recognized any more.
	# The default value is: NO.

	MULTILINE_CPP_IS_BRIEF = NO

	# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
	# documentation from any documented member that it re-implements.
	# The default value is: YES.

	INHERIT_DOCS = YES

	# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
	# page for each member. If set to NO, the documentation of a member will be part
	# of the file/class/namespace that contains it.
	# The default value is: NO.

	SEPARATE_MEMBER_PAGES = NO

	# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
	# uses this value to replace tabs by spaces in code fragments.
	# Minimum value: 1, maximum value: 16, default value: 4.

	TAB_SIZE = 4

	# This tag can be used to specify a number of aliases that act as commands in
	# the documentation. An alias has the form:
	# name=value
	# For example adding
	# "sideeffect=@par Side Effects:\n"
	# will allow you to put the command \sideeffect (or @sideeffect) in the
	# documentation, which will result in a user-defined paragraph with heading
	# "Side Effects:". You can put \n's in the value part of an alias to insert
	# newlines.

	ALIASES =

	# This tag can be used to specify a number of word-keyword mappings (TCL only).
	# A mapping has the form "name=value". For example adding "class=itcl::class"
	# will allow you to use the command class in the itcl::class meaning.

	TCL_SUBST =

	# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
	# only. Doxygen will then generate output that is more tailored for C. For
	# instance, some of the names that are used will be different. The list of all
	# members will be omitted, etc.
	# The default value is: NO.

	OPTIMIZE_OUTPUT_FOR_C = YES

	# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
	# Python sources only. Doxygen will then generate output that is more tailored
	# for that language. For instance, namespaces will be presented as packages,
	# qualified scopes will look different, etc.
	# The default value is: NO.

	OPTIMIZE_OUTPUT_JAVA = NO

	# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
	# sources. Doxygen will then generate output that is tailored for Fortran.
	# The default value is: NO.

	OPTIMIZE_FOR_FORTRAN = NO

	# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
	# sources. Doxygen will then generate output that is tailored for VHDL.
	# The default value is: NO.

	OPTIMIZE_OUTPUT_VHDL = NO

	# Doxygen selects the parser to use depending on the extension of the files it
	# parses. With this tag you can assign which parser to use for a given
	# extension. Doxygen has a built-in mapping, but you can override or extend it
	# using this tag. The format is ext=language, where ext is a file extension, and
	# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
	# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
	# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
	# Fortran. In the later case the parser tries to guess whether the code is fixed
	# or free formatted code, this is the default for Fortran type files), VHDL. For
	# instance to make doxygen treat .inc files as Fortran files (default is PHP),
	# and .f files as C (default is Fortran), use: inc=Fortran f=C.
	#
	# Note: For files without extension you can use no_extension as a placeholder.
	#
	# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
	# the files are not read by doxygen.

	EXTENSION_MAPPING =

	# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
	# according to the Markdown format, which allows for more readable
	# documentation. See http://daringfireball.net/projects/markdown/ for details.
	# The output of markdown processing is further processed by doxygen, so you can
	# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
	# case of backward compatibilities issues.
	# The default value is: YES.

	MARKDOWN_SUPPORT = YES

	# When enabled doxygen tries to link words that correspond to documented
	# classes, or namespaces to their corresponding documentation. Such a link can
	# be prevented in individual cases by putting a % sign in front of the word or
	# globally by setting AUTOLINK_SUPPORT to NO.
	# The default value is: YES.

	AUTOLINK_SUPPORT = YES

	# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
	# to include (a tag file for) the STL sources as input, then you should set this
	# tag to YES in order to let doxygen match functions declarations and
	# definitions whose arguments contain STL classes (e.g. func(std::string);
	# versus func(std::string) {}). This also make the inheritance and collaboration
	# diagrams that involve STL classes more complete and accurate.
	# The default value is: NO.

	BUILTIN_STL_SUPPORT = NO

	# If you use Microsoft's C++/CLI language, you should set this option to YES to
	# enable parsing support.
	# The default value is: NO.

	CPP_CLI_SUPPORT = NO

	# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
	# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
	# will parse them like normal C++ but will assume all classes use public instead
	# of private inheritance when no explicit protection keyword is present.
	# The default value is: NO.

	SIP_SUPPORT = NO

	# For Microsoft's IDL there are propget and propput attributes to indicate
	# getter and setter methods for a property. Setting this option to YES will make
	# doxygen to replace the get and set methods by a property in the documentation.
	# This will only work if the methods are indeed getting or setting a simple
	# type. If this is not the case, or you want to show the methods anyway, you
	# should set this option to NO.
	# The default value is: YES.

	IDL_PROPERTY_SUPPORT = YES

	# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
	# tag is set to YES then doxygen will reuse the documentation of the first
	# member in the group (if any) for the other members of the group. By default
	# all members of a group must be documented explicitly.
	# The default value is: NO.

	DISTRIBUTE_GROUP_DOC = NO

	# If one adds a struct or class to a group and this option is enabled, then also
	# any nested class or struct is added to the same group. By default this option
	# is disabled and one has to add nested compounds explicitly via \ingroup.
	# The default value is: NO.

	GROUP_NESTED_COMPOUNDS = NO

	# Set the SUBGROUPING tag to YES to allow class member groups of the same type
	# (for instance a group of public functions) to be put as a subgroup of that
	# type (e.g. under the Public Functions section). Set it to NO to prevent
	# subgrouping. Alternatively, this can be done per class using the
	# \nosubgrouping command.
	# The default value is: YES.

	SUBGROUPING = YES

	# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
	# are shown inside the group in which they are included (e.g. using \ingroup)
	# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
	# and RTF).
	#
	# Note that this feature does not work in combination with
	# SEPARATE_MEMBER_PAGES.
	# The default value is: NO.

	INLINE_GROUPED_CLASSES = NO

	# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
	# with only public data fields or simple typedef fields will be shown inline in
	# the documentation of the scope in which they are defined (i.e. file,
	# namespace, or group documentation), provided this scope is documented. If set
	# to NO, structs, classes, and unions are shown on a separate page (for HTML and
	# Man pages) or section (for LaTeX and RTF).
	# The default value is: NO.

	-INLINE_SIMPLE_STRUCTS = YES
	+INLINE_SIMPLE_STRUCTS = NO

	# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
	# enum is documented as struct, union, or enum with the name of the typedef. So
	# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
	# with name TypeT. When disabled the typedef will appear as a member of a file,
	# namespace, or class. And the struct will be named TypeS. This can typically be
	# useful for C code in case the coding convention dictates that all compound
	# types are typedef'ed and only the typedef is referenced, never the tag name.
	# The default value is: NO.

	TYPEDEF_HIDES_STRUCT = NO

	# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
	# cache is used to resolve symbols given their name and scope. Since this can be
	# an expensive process and often the same symbol appears multiple times in the
	# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
	# doxygen will become slower. If the cache is too large, memory is wasted. The
	# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
	# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
	# symbols. At the end of a run doxygen will report the cache usage and suggest
	# the optimal cache size from a speed point of view.
	# Minimum value: 0, maximum value: 9, default value: 0.

	LOOKUP_CACHE_SIZE = 0

	#---------------------------------------------------------------------------
	# Build related configuration options
	#---------------------------------------------------------------------------

	# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
	# documentation are documented, even if no documentation was available. Private
	# class members and static file members will be hidden unless the
	# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
	# Note: This will also disable the warnings about undocumented members that are
	# normally produced when WARNINGS is set to YES.
	# The default value is: NO.

	EXTRACT_ALL = NO

	# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
	# be included in the documentation.
	# The default value is: NO.

	-EXTRACT_PRIVATE = YES
	+EXTRACT_PRIVATE = NO

	# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
	# scope will be included in the documentation.
	# The default value is: NO.

	-EXTRACT_PACKAGE = YES
	+EXTRACT_PACKAGE = NO

	# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
	# included in the documentation.
	# The default value is: NO.

	-EXTRACT_STATIC = YES
	+EXTRACT_STATIC = NO

	# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
	# locally in source files will be included in the documentation. If set to NO,
	# only classes defined in header files are included. Does not have any effect
	# for Java sources.
	# The default value is: YES.

	EXTRACT_LOCAL_CLASSES = YES

	# This flag is only useful for Objective-C code. If set to YES, local methods,
	# which are defined in the implementation section but not in the interface are
	# included in the documentation. If set to NO, only methods in the interface are
	# included.
	# The default value is: NO.

	-EXTRACT_LOCAL_METHODS = YES
	+EXTRACT_LOCAL_METHODS = NO

	# If this flag is set to YES, the members of anonymous namespaces will be
	# extracted and appear in the documentation as a namespace called
	# 'anonymous_namespace{file}', where file will be replaced with the base name of
	# the file that contains the anonymous namespace. By default anonymous namespace
	# are hidden.
	# The default value is: NO.

	EXTRACT_ANON_NSPACES = YES

	# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
	# undocumented members inside documented classes or files. If set to NO these
	# members will be included in the various overviews, but no documentation
	# section is generated. This option has no effect if EXTRACT_ALL is enabled.
	# The default value is: NO.

	HIDE_UNDOC_MEMBERS = NO

	# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
	# undocumented classes that are normally visible in the class hierarchy. If set
	# to NO, these classes will be included in the various overviews. This option
	# has no effect if EXTRACT_ALL is enabled.
	# The default value is: NO.

	HIDE_UNDOC_CLASSES = NO

	# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
	# (class\|struct\|union) declarations. If set to NO, these declarations will be
	# included in the documentation.
	# The default value is: NO.

	HIDE_FRIEND_COMPOUNDS = NO

	# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
	# documentation blocks found inside the body of a function. If set to NO, these
	# blocks will be appended to the function's detailed documentation block.
	# The default value is: NO.

	HIDE_IN_BODY_DOCS = NO

	# The INTERNAL_DOCS tag determines if documentation that is typed after a
	# \internal command is included. If the tag is set to NO then the documentation
	# will be excluded. Set it to YES to include the internal documentation.
	# The default value is: NO.

	INTERNAL_DOCS = NO

	# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
	# names in lower-case letters. If set to YES, upper-case letters are also
	# allowed. This is useful if you have classes or files whose names only differ
	# in case and if your file system supports case sensitive file names. Windows
	# and Mac users are advised to set this option to NO.
	# The default value is: system dependent.

	CASE_SENSE_NAMES = YES

	# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
	# their full class and namespace scopes in the documentation. If set to YES, the
	# scope will be hidden.
	# The default value is: NO.

	HIDE_SCOPE_NAMES = NO

	# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
	# append additional text to a page's title, such as Class Reference. If set to
	# YES the compound reference will be hidden.
	# The default value is: NO.

	HIDE_COMPOUND_REFERENCE= NO

	# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
	# the files that are included by a file in the documentation of that file.
	# The default value is: YES.

	SHOW_INCLUDE_FILES = NO

	# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
	# grouped member an include statement to the documentation, telling the reader
	# which file to include in order to use the member.
	# The default value is: NO.

	SHOW_GROUPED_MEMB_INC = NO

	# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
	# files with double quotes in the documentation rather than with sharp brackets.
	# The default value is: NO.

	FORCE_LOCAL_INCLUDES = NO

	# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
	# documentation for inline members.
	# The default value is: YES.

	INLINE_INFO = YES

	# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
	# (detailed) documentation of file and class members alphabetically by member
	# name. If set to NO, the members will appear in declaration order.
	# The default value is: YES.

	SORT_MEMBER_DOCS = YES

	# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
	# descriptions of file, namespace and class members alphabetically by member
	# name. If set to NO, the members will appear in declaration order. Note that
	# this will also influence the order of the classes in the class list.
	# The default value is: NO.

	SORT_BRIEF_DOCS = YES

	# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
	# (brief and detailed) documentation of class members so that constructors and
	# destructors are listed first. If set to NO the constructors will appear in the
	# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
	# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
	# member documentation.
	# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
	# detailed member documentation.
	# The default value is: NO.

	SORT_MEMBERS_CTORS_1ST = YES

	# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
	# of group names into alphabetical order. If set to NO the group names will
	# appear in their defined order.
	# The default value is: NO.

	SORT_GROUP_NAMES = NO

	# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
	# fully-qualified names, including namespaces. If set to NO, the class list will
	# be sorted only by class name, not including the namespace part.
	# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
	# Note: This option applies only to the class list, not to the alphabetical
	# list.
	# The default value is: NO.

	SORT_BY_SCOPE_NAME = NO

	# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
	# type resolution of all parameters of a function it will reject a match between
	# the prototype and the implementation of a member function even if there is
	# only one candidate or it is obvious which candidate to choose by doing a
	# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
	# accept a match between prototype and implementation in such cases.
	# The default value is: NO.

	STRICT_PROTO_MATCHING = NO

	# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
	# list. This list is created by putting \todo commands in the documentation.
	# The default value is: YES.

	GENERATE_TODOLIST = YES

	# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
	# list. This list is created by putting \test commands in the documentation.
	# The default value is: YES.

	GENERATE_TESTLIST = YES

	# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
	# list. This list is created by putting \bug commands in the documentation.
	# The default value is: YES.

	GENERATE_BUGLIST = YES

	# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
	# the deprecated list. This list is created by putting \deprecated commands in
	# the documentation.
	# The default value is: YES.

	GENERATE_DEPRECATEDLIST= YES

	# The ENABLED_SECTIONS tag can be used to enable conditional documentation
	# sections, marked by \if <section_label> ... \endif and \cond <section_label>
	# ... \endcond blocks.

	ENABLED_SECTIONS =

	# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
	# initial value of a variable or macro / define can have for it to appear in the
	# documentation. If the initializer consists of more lines than specified here
	# it will be hidden. Use a value of 0 to hide initializers completely. The
	# appearance of the value of individual variables and macros / defines can be
	# controlled using \showinitializer or \hideinitializer command in the
	# documentation regardless of this setting.
	# Minimum value: 0, maximum value: 10000, default value: 30.

	MAX_INITIALIZER_LINES = 30

	# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
	# the bottom of the documentation of classes and structs. If set to YES, the
	# list will mention the files that were used to generate the documentation.
	# The default value is: YES.

	SHOW_USED_FILES = NO

	# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
	# will remove the Files entry from the Quick Index and from the Folder Tree View
	# (if specified).
	# The default value is: YES.

	SHOW_FILES = NO

	# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
	# page. This will remove the Namespaces entry from the Quick Index and from the
	# Folder Tree View (if specified).
	# The default value is: YES.

	SHOW_NAMESPACES = NO

	# The FILE_VERSION_FILTER tag can be used to specify a program or script that
	# doxygen should invoke to get the current version for each file (typically from
	# the version control system). Doxygen will invoke the program by executing (via
	# popen()) the command command input-file, where command is the value of the
	# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
	# by doxygen. Whatever the program writes to standard output is used as the file
	# version. For an example see the documentation.

	FILE_VERSION_FILTER =

	# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
	# by doxygen. The layout file controls the global structure of the generated
	# output files in an output format independent way. To create the layout file
	# that represents doxygen's defaults, run doxygen with the -l option. You can
	# optionally specify a file name after the option, if omitted DoxygenLayout.xml
	# will be used as the name of the layout file.
	#
	# Note that if you run doxygen from a directory containing a file called
	# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
	# tag is left empty.

	LAYOUT_FILE =

	# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
	# the reference definitions. This must be a list of .bib files. The .bib
	# extension is automatically appended if omitted. This requires the bibtex tool
	# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
	# For LaTeX the style of the bibliography can be controlled using
	# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
	# search path. See also \cite for info how to create references.

	CITE_BIB_FILES = doc/biblio.bib

	#---------------------------------------------------------------------------
	# Configuration options related to warning and progress messages
	#---------------------------------------------------------------------------

	# The QUIET tag can be used to turn on/off the messages that are generated to
	# standard output by doxygen. If QUIET is set to YES this implies that the
	# messages are off.
	# The default value is: NO.

	QUIET = YES

	# The WARNINGS tag can be used to turn on/off the warning messages that are
	# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
	# this implies that the warnings are on.
	#
	# Tip: Turn warnings on while writing the documentation.
	# The default value is: YES.

	WARNINGS = YES

	# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
	# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
	# will automatically be disabled.
	# The default value is: YES.

	WARN_IF_UNDOCUMENTED = YES

	# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
	# potential errors in the documentation, such as not documenting some parameters
	# in a documented function, or documenting parameters that don't exist or using
	# markup commands wrongly.
	# The default value is: YES.

	WARN_IF_DOC_ERROR = YES

	# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
	# are documented, but have no documentation for their parameters or return
	# value. If set to NO, doxygen will only warn about wrong or incomplete
	# parameter documentation, but not about the absence of documentation.
	# The default value is: NO.

	WARN_NO_PARAMDOC = YES

	# The WARN_FORMAT tag determines the format of the warning messages that doxygen
	# can produce. The string should contain the $file, $line, and $text tags, which
	# will be replaced by the file and line number from which the warning originated
	# and the warning text. Optionally the format may contain $version, which will
	# be replaced by the version of the file (if it could be obtained via
	# FILE_VERSION_FILTER)
	# The default value is: $file:$line: $text.

	WARN_FORMAT = "$file:$line: $text"

	# The WARN_LOGFILE tag can be used to specify a file to which warning and error
	# messages should be written. If left blank the output is written to standard
	# error (stderr).

	WARN_LOGFILE =

	#---------------------------------------------------------------------------
	# Configuration options related to the input files
	#---------------------------------------------------------------------------

	# The INPUT tag is used to specify the files and/or directories that contain
	# documented source files. You may enter file names like myfile.cpp or
	# directories like /usr/src/myproject. Separate the files or directories with
	# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
	# Note: If this tag is empty the current directory is searched.

	INPUT = main.cpp \
	core/ \
	physics/ \
	export/ \
	external/ \
	processes/ \
	hadronisers/

	# This tag can be used to specify the character encoding of the source files
	# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
	# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
	# documentation (see: http://www.gnu.org/software/libiconv) for the list of
	# possible encodings.
	# The default value is: UTF-8.

	INPUT_ENCODING = UTF-8

	# If the value of the INPUT tag contains directories, you can use the
	# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
	# *.h) to filter out the source-files in the directories.
	#
	# Note that for custom extensions or not directly supported extensions you also
	# need to set EXTENSION_MAPPING for the extension otherwise the files are not
	# read by doxygen.
	#
	# If left blank the following patterns are tested:.c, .cc, .cxx, .cpp,
	# .c++, .java, .ii, .ixx, .ipp, .i++, .inl, .idl, .ddl, .odl, *.h,
	# .hh, .hxx, .hpp, .h++, .cs, .d, .php, .php4, .php5, .phtml, *.inc,
	# .m, .markdown, .md, .mm, .dox, .py, .f90, .f, .for, .tcl, *.vhd,
	# .vhdl, .ucf, .qsf, .as and *.js.

	FILE_PATTERNS =

	# The RECURSIVE tag can be used to specify whether or not subdirectories should
	# be searched for input files as well.
	# The default value is: NO.

	RECURSIVE = NO

	# The EXCLUDE tag can be used to specify files and/or directories that should be
	# excluded from the INPUT source files. This way you can easily exclude a
	# subdirectory from a directory tree whose root is specified with the INPUT tag.
	#
	# Note that relative paths are relative to the directory from which doxygen is
	# run.

	EXCLUDE = include/gnuplot.h

	# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
	# directories that are symbolic links (a Unix file system feature) are excluded
	# from the input.
	# The default value is: NO.

	EXCLUDE_SYMLINKS = NO

	# If the value of the INPUT tag contains directories, you can use the
	# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
	# certain files from those directories.
	#
	# Note that the wildcards are matched against the file with absolute path, so to
	# exclude all test directories for example use the pattern /test/

	EXCLUDE_PATTERNS =

	# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
	# (namespaces, classes, functions, etc.) that should be excluded from the
	# output. The symbol name can be a fully qualified name, a word, or if the
	# wildcard * is used, a substring. Examples: ANamespace, AClass,
	# AClass::ANamespace, ANamespace::*Test
	#
	# Note that the wildcards are matched against the file with absolute path, so to
	# exclude all test directories use the pattern /test/

	EXCLUDE_SYMBOLS =

	# The EXAMPLE_PATH tag can be used to specify one or more files or directories
	# that contain example code fragments that are included (see the \include
	# command).

	EXAMPLE_PATH = main.cpp \
	utils/xsect.cpp

	# If the value of the EXAMPLE_PATH tag contains directories, you can use the
	# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
	# *.h) to filter out the source-files in the directories. If left blank all
	# files are included.

	EXAMPLE_PATTERNS =

	# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
	# searched for input files to be used with the \include or \dontinclude commands
	# irrespective of the value of the RECURSIVE tag.
	# The default value is: NO.

	EXAMPLE_RECURSIVE = NO

	# The IMAGE_PATH tag can be used to specify one or more files or directories
	# that contain images that are to be included in the documentation (see the
	# \image command).

	IMAGE_PATH = doc/

	# The INPUT_FILTER tag can be used to specify a program that doxygen should
	# invoke to filter for each input file. Doxygen will invoke the filter program
	# by executing (via popen()) the command:
	#
	# <filter> <input-file>
	#
	# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
	# name of an input file. Doxygen will then use the output that the filter
	# program writes to standard output. If FILTER_PATTERNS is specified, this tag
	# will be ignored.
	#
	# Note that the filter must not add or remove lines; it is applied before the
	# code is scanned, but not when the output code is generated. If lines are added
	# or removed, the anchors will not be placed correctly.

	INPUT_FILTER =

	# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
	# basis. Doxygen will compare the file name with each pattern and apply the
	# filter if there is a match. The filters are a list of the form: pattern=filter
	# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
	# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
	# patterns match the file name, INPUT_FILTER is applied.

	FILTER_PATTERNS =

	# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
	# INPUT_FILTER) will also be used to filter the input files that are used for
	# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
	# The default value is: NO.

	FILTER_SOURCE_FILES = NO

	# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
	# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
	# it is also possible to disable source filtering for a specific pattern using
	# *.ext= (so without naming a filter).
	# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.

	FILTER_SOURCE_PATTERNS =

	# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
	# is part of the input, its contents will be placed on the main page
	# (index.html). This can be useful if you have a project on for instance GitHub
	# and want to reuse the introduction page also for the doxygen output.

	USE_MDFILE_AS_MAINPAGE =

	#---------------------------------------------------------------------------
	# Configuration options related to source browsing
	#---------------------------------------------------------------------------

	# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
	# generated. Documented entities will be cross-referenced with these sources.
	#
	# Note: To get rid of all source code in the generated output, make sure that
	# also VERBATIM_HEADERS is set to NO.
	# The default value is: NO.

	SOURCE_BROWSER = NO

	# Setting the INLINE_SOURCES tag to YES will include the body of functions,
	# classes and enums directly into the documentation.
	# The default value is: NO.

	INLINE_SOURCES = NO

	# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
	# special comment blocks from generated source code fragments. Normal C, C++ and
	# Fortran comments will always remain visible.
	# The default value is: YES.

	STRIP_CODE_COMMENTS = YES

	# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
	# function all documented functions referencing it will be listed.
	# The default value is: NO.

	REFERENCED_BY_RELATION = NO

	# If the REFERENCES_RELATION tag is set to YES then for each documented function
	# all documented entities called/used by that function will be listed.
	# The default value is: NO.

	REFERENCES_RELATION = NO

	# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
	# to YES then the hyperlinks from functions in REFERENCES_RELATION and
	# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
	# link to the documentation.
	# The default value is: YES.

	REFERENCES_LINK_SOURCE = YES

	# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
	# source code will show a tooltip with additional information such as prototype,
	# brief description and links to the definition and documentation. Since this
	# will make the HTML file larger and loading of large files a bit slower, you
	# can opt to disable this feature.
	# The default value is: YES.
	# This tag requires that the tag SOURCE_BROWSER is set to YES.

	SOURCE_TOOLTIPS = YES

	# If the USE_HTAGS tag is set to YES then the references to source code will
	# point to the HTML generated by the htags(1) tool instead of doxygen built-in
	# source browser. The htags tool is part of GNU's global source tagging system
	# (see http://www.gnu.org/software/global/global.html). You will need version
	# 4.8.6 or higher.
	#
	# To use it do the following:
	# - Install the latest version of global
	# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
	# - Make sure the INPUT points to the root of the source tree
	# - Run doxygen as normal
	#
	# Doxygen will invoke htags (and that will in turn invoke gtags), so these
	# tools must be available from the command line (i.e. in the search path).
	#
	# The result: instead of the source browser generated by doxygen, the links to
	# source code will now point to the output of htags.
	# The default value is: NO.
	# This tag requires that the tag SOURCE_BROWSER is set to YES.

	USE_HTAGS = NO

	# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
	# verbatim copy of the header file for each class for which an include is
	# specified. Set to NO to disable this.
	# See also: Section \class.
	# The default value is: YES.

	VERBATIM_HEADERS = YES

	#---------------------------------------------------------------------------
	# Configuration options related to the alphabetical class index
	#---------------------------------------------------------------------------

	# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
	# compounds will be generated. Enable this if the project contains a lot of
	# classes, structs, unions or interfaces.
	# The default value is: YES.

	ALPHABETICAL_INDEX = YES

	# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
	# which the alphabetical index list will be split.
	# Minimum value: 1, maximum value: 20, default value: 5.
	# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.

	COLS_IN_ALPHA_INDEX = 5

	# In case all classes in a project start with a common prefix, all classes will
	# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
	# can be used to specify a prefix (or a list of prefixes) that should be ignored
	# while generating the index headers.
	# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.

	IGNORE_PREFIX =

	#---------------------------------------------------------------------------
	# Configuration options related to the HTML output
	#---------------------------------------------------------------------------

	# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
	# The default value is: YES.

	GENERATE_HTML = NO

	# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
	# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
	# it.
	# The default directory is: html.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_OUTPUT = html

	# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
	# generated HTML page (for example: .htm, .php, .asp).
	# The default value is: .html.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_FILE_EXTENSION = .html

	# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
	# each generated HTML page. If the tag is left blank doxygen will generate a
	# standard header.
	#
	# To get valid HTML the header file that includes any scripts and style sheets
	# that doxygen needs, which is dependent on the configuration options used (e.g.
	# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
	# default header using
	# doxygen -w html new_header.html new_footer.html new_stylesheet.css
	# YourConfigFile
	# and then modify the file new_header.html. See also section "Doxygen usage"
	# for information on how to generate the default header that doxygen normally
	# uses.
	# Note: The header is subject to change so you typically have to regenerate the
	# default header when upgrading to a newer version of doxygen. For a description
	# of the possible markers and block names see the documentation.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_HEADER =

	# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
	# generated HTML page. If the tag is left blank doxygen will generate a standard
	# footer. See HTML_HEADER for more information on how to generate a default
	# footer and what special commands can be used inside the footer. See also
	# section "Doxygen usage" for information on how to generate the default footer
	# that doxygen normally uses.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_FOOTER =

	# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
	# sheet that is used by each HTML page. It can be used to fine-tune the look of
	# the HTML output. If left blank doxygen will generate a default style sheet.
	# See also section "Doxygen usage" for information on how to generate the style
	# sheet that doxygen normally uses.
	# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
	# it is more robust and this tag (HTML_STYLESHEET) will in the future become
	# obsolete.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_STYLESHEET =

	# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
	# cascading style sheets that are included after the standard style sheets
	# created by doxygen. Using this option one can overrule certain style aspects.
	# This is preferred over using HTML_STYLESHEET since it does not replace the
	# standard style sheet and is therefore more robust against future updates.
	# Doxygen will copy the style sheet files to the output directory.
	# Note: The order of the extra style sheet files is of importance (e.g. the last
	# style sheet in the list overrules the setting of the previous ones in the
	# list). For an example see the documentation.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_EXTRA_STYLESHEET =

	# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
	# other source files which should be copied to the HTML output directory. Note
	# that these files will be copied to the base HTML output directory. Use the
	# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
	# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
	# files will be copied as-is; there are no commands or markers available.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_EXTRA_FILES =

	# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
	# will adjust the colors in the style sheet and background images according to
	# this color. Hue is specified as an angle on a colorwheel, see
	# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
	# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
	# purple, and 360 is red again.
	# Minimum value: 0, maximum value: 359, default value: 220.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_COLORSTYLE_HUE = 220

	# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
	# in the HTML output. For a value of 0 the output will use grayscales only. A
	# value of 255 will produce the most vivid colors.
	# Minimum value: 0, maximum value: 255, default value: 100.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_COLORSTYLE_SAT = 100

	# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
	# luminance component of the colors in the HTML output. Values below 100
	# gradually make the output lighter, whereas values above 100 make the output
	# darker. The value divided by 100 is the actual gamma applied, so 80 represents
	# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
	# change the gamma.
	# Minimum value: 40, maximum value: 240, default value: 80.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_COLORSTYLE_GAMMA = 80

	# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
	# page will contain the date and time when the page was generated. Setting this
	# to YES can help to show when doxygen was last run and thus if the
	# documentation is up to date.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_TIMESTAMP = NO

	# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
	# documentation will contain sections that can be hidden and shown after the
	# page has loaded.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_DYNAMIC_SECTIONS = NO

	# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
	# shown in the various tree structured indices initially; the user can expand
	# and collapse entries dynamically later on. Doxygen will expand the tree to
	# such a level that at most the specified number of entries are visible (unless
	# a fully collapsed tree already exceeds this amount). So setting the number of
	# entries 1 will produce a full collapsed tree by default. 0 is a special value
	# representing an infinite number of entries and will result in a full expanded
	# tree by default.
	# Minimum value: 0, maximum value: 9999, default value: 100.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	HTML_INDEX_NUM_ENTRIES = 100

	# If the GENERATE_DOCSET tag is set to YES, additional index files will be
	# generated that can be used as input for Apple's Xcode 3 integrated development
	# environment (see: http://developer.apple.com/tools/xcode/), introduced with
	# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
	# Makefile in the HTML output directory. Running make will produce the docset in
	# that directory and running make install will install the docset in
	# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
	# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
	# for more information.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	GENERATE_DOCSET = NO

	# This tag determines the name of the docset feed. A documentation feed provides
	# an umbrella under which multiple documentation sets from a single provider
	# (such as a company or product suite) can be grouped.
	# The default value is: Doxygen generated docs.
	# This tag requires that the tag GENERATE_DOCSET is set to YES.

	DOCSET_FEEDNAME = "Doxygen generated docs"

	# This tag specifies a string that should uniquely identify the documentation
	# set bundle. This should be a reverse domain-name style string, e.g.
	# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
	# The default value is: org.doxygen.Project.
	# This tag requires that the tag GENERATE_DOCSET is set to YES.

	DOCSET_BUNDLE_ID = org.doxygen.Project

	# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
	# the documentation publisher. This should be a reverse domain-name style
	# string, e.g. com.mycompany.MyDocSet.documentation.
	# The default value is: org.doxygen.Publisher.
	# This tag requires that the tag GENERATE_DOCSET is set to YES.

	DOCSET_PUBLISHER_ID = org.doxygen.Publisher

	# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
	# The default value is: Publisher.
	# This tag requires that the tag GENERATE_DOCSET is set to YES.

	DOCSET_PUBLISHER_NAME = Publisher

	# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
	# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
	# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
	# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
	# Windows.
	#
	# The HTML Help Workshop contains a compiler that can convert all HTML output
	# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
	# files are now used as the Windows 98 help format, and will replace the old
	# Windows help format (.hlp) on all Windows platforms in the future. Compressed
	# HTML files also contain an index, a table of contents, and you can search for
	# words in the documentation. The HTML workshop also contains a viewer for
	# compressed HTML files.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	GENERATE_HTMLHELP = NO

	# The CHM_FILE tag can be used to specify the file name of the resulting .chm
	# file. You can add a path in front of the file if the result should not be
	# written to the html output directory.
	# This tag requires that the tag GENERATE_HTMLHELP is set to YES.

	CHM_FILE =

	# The HHC_LOCATION tag can be used to specify the location (absolute path
	# including file name) of the HTML help compiler (hhc.exe). If non-empty,
	# doxygen will try to run the HTML help compiler on the generated index.hhp.
	# The file has to be specified with full path.
	# This tag requires that the tag GENERATE_HTMLHELP is set to YES.

	HHC_LOCATION =

	# The GENERATE_CHI flag controls if a separate .chi index file is generated
	# (YES) or that it should be included in the master .chm file (NO).
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTMLHELP is set to YES.

	GENERATE_CHI = NO

	# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
	# and project file content.
	# This tag requires that the tag GENERATE_HTMLHELP is set to YES.

	CHM_INDEX_ENCODING =

	# The BINARY_TOC flag controls whether a binary table of contents is generated
	# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
	# enables the Previous and Next buttons.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTMLHELP is set to YES.

	BINARY_TOC = NO

	# The TOC_EXPAND flag can be set to YES to add extra items for group members to
	# the table of contents of the HTML help documentation and to the tree view.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTMLHELP is set to YES.

	TOC_EXPAND = NO

	# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
	# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
	# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
	# (.qch) of the generated HTML documentation.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	GENERATE_QHP = NO

	# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
	# the file name of the resulting .qch file. The path specified is relative to
	# the HTML output folder.
	# This tag requires that the tag GENERATE_QHP is set to YES.

	QCH_FILE =

	# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
	# Project output. For more information please see Qt Help Project / Namespace
	# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
	# The default value is: org.doxygen.Project.
	# This tag requires that the tag GENERATE_QHP is set to YES.

	QHP_NAMESPACE = org.doxygen.Project

	# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
	# Help Project output. For more information please see Qt Help Project / Virtual
	# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
	# folders).
	# The default value is: doc.
	# This tag requires that the tag GENERATE_QHP is set to YES.

	QHP_VIRTUAL_FOLDER = doc

	# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
	# filter to add. For more information please see Qt Help Project / Custom
	# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
	# filters).
	# This tag requires that the tag GENERATE_QHP is set to YES.

	QHP_CUST_FILTER_NAME =

	# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
	# custom filter to add. For more information please see Qt Help Project / Custom
	# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
	# filters).
	# This tag requires that the tag GENERATE_QHP is set to YES.

	QHP_CUST_FILTER_ATTRS =

	# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
	# project's filter section matches. Qt Help Project / Filter Attributes (see:
	# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
	# This tag requires that the tag GENERATE_QHP is set to YES.

	QHP_SECT_FILTER_ATTRS =

	# The QHG_LOCATION tag can be used to specify the location of Qt's
	# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
	# generated .qhp file.
	# This tag requires that the tag GENERATE_QHP is set to YES.

	QHG_LOCATION =

	# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
	# generated, together with the HTML files, they form an Eclipse help plugin. To
	# install this plugin and make it available under the help contents menu in
	# Eclipse, the contents of the directory containing the HTML and XML files needs
	# to be copied into the plugins directory of eclipse. The name of the directory
	# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
	# After copying Eclipse needs to be restarted before the help appears.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	GENERATE_ECLIPSEHELP = NO

	# A unique identifier for the Eclipse help plugin. When installing the plugin
	# the directory name containing the HTML and XML files should also have this
	# name. Each documentation set should have its own identifier.
	# The default value is: org.doxygen.Project.
	# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.

	ECLIPSE_DOC_ID = org.doxygen.Project

	# If you want full control over the layout of the generated HTML pages it might
	# be necessary to disable the index and replace it with your own. The
	# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
	# of each HTML page. A value of NO enables the index and the value YES disables
	# it. Since the tabs in the index contain the same information as the navigation
	# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	DISABLE_INDEX = NO

	# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
	# structure should be generated to display hierarchical information. If the tag
	# value is set to YES, a side panel will be generated containing a tree-like
	# index structure (just like the one that is generated for HTML Help). For this
	# to work a browser that supports JavaScript, DHTML, CSS and frames is required
	# (i.e. any modern browser). Windows users are probably better off using the
	# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
	# further fine-tune the look of the index. As an example, the default style
	# sheet generated by doxygen has an example that shows how to put an image at
	# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
	# the same information as the tab index, you could consider setting
	# DISABLE_INDEX to YES when enabling this option.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	GENERATE_TREEVIEW = NO

	# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
	# doxygen will group on one line in the generated HTML documentation.
	#
	# Note that a value of 0 will completely suppress the enum values from appearing
	# in the overview section.
	# Minimum value: 0, maximum value: 20, default value: 4.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	ENUM_VALUES_PER_LINE = 4

	# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
	# to set the initial width (in pixels) of the frame in which the tree is shown.
	# Minimum value: 0, maximum value: 1500, default value: 250.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	TREEVIEW_WIDTH = 250

	# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
	# external symbols imported via tag files in a separate window.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	EXT_LINKS_IN_WINDOW = NO

	# Use this tag to change the font size of LaTeX formulas included as images in
	# the HTML documentation. When you change the font size after a successful
	# doxygen run you need to manually remove any form_*.png images from the HTML
	# output directory to force them to be regenerated.
	# Minimum value: 8, maximum value: 50, default value: 10.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	FORMULA_FONTSIZE = 10

	# Use the FORMULA_TRANPARENT tag to determine whether or not the images
	# generated for formulas are transparent PNGs. Transparent PNGs are not
	# supported properly for IE 6.0, but are supported on all modern browsers.
	#
	# Note that when changing this option you need to delete any form_*.png files in
	# the HTML output directory before the changes have effect.
	# The default value is: YES.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	FORMULA_TRANSPARENT = YES

	# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
	# http://www.mathjax.org) which uses client side Javascript for the rendering
	# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
	# installed or if you want to formulas look prettier in the HTML output. When
	# enabled you may also need to install MathJax separately and configure the path
	# to it using the MATHJAX_RELPATH option.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	USE_MATHJAX = NO

	# When MathJax is enabled you can set the default output format to be used for
	# the MathJax output. See the MathJax site (see:
	# http://docs.mathjax.org/en/latest/output.html) for more details.
	# Possible values are: HTML-CSS (which is slower, but has the best
	# compatibility), NativeMML (i.e. MathML) and SVG.
	# The default value is: HTML-CSS.
	# This tag requires that the tag USE_MATHJAX is set to YES.

	MATHJAX_FORMAT = HTML-CSS

	# When MathJax is enabled you need to specify the location relative to the HTML
	# output directory using the MATHJAX_RELPATH option. The destination directory
	# should contain the MathJax.js script. For instance, if the mathjax directory
	# is located at the same level as the HTML output directory, then
	# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
	# Content Delivery Network so you can quickly see the result without installing
	# MathJax. However, it is strongly recommended to install a local copy of
	# MathJax from http://www.mathjax.org before deployment.
	# The default value is: http://cdn.mathjax.org/mathjax/latest.
	# This tag requires that the tag USE_MATHJAX is set to YES.

	MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest

	# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
	# extension names that should be enabled during MathJax rendering. For example
	# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
	# This tag requires that the tag USE_MATHJAX is set to YES.

	MATHJAX_EXTENSIONS =

	# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
	# of code that will be used on startup of the MathJax code. See the MathJax site
	# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
	# example see the documentation.
	# This tag requires that the tag USE_MATHJAX is set to YES.

	MATHJAX_CODEFILE =

	# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
	# the HTML output. The underlying search engine uses javascript and DHTML and
	# should work on any modern browser. Note that when using HTML help
	# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
	# there is already a search function so this one should typically be disabled.
	# For large projects the javascript based search engine can be slow, then
	# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
	# search using the keyboard; to jump to the search box use <access key> + S
	# (what the <access key> is depends on the OS and browser, but it is typically
	# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
	# key> to jump into the search results window, the results can be navigated
	# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
	# the search. The filter options can be selected when the cursor is inside the
	# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
	# to select a filter and <Enter> or <escape> to activate or cancel the filter
	# option.
	# The default value is: YES.
	# This tag requires that the tag GENERATE_HTML is set to YES.

	SEARCHENGINE = YES

	# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
	# implemented using a web server instead of a web client using Javascript. There
	# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
	# setting. When disabled, doxygen will generate a PHP script for searching and
	# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
	# and searching needs to be provided by external tools. See the section
	# "External Indexing and Searching" for details.
	# The default value is: NO.
	# This tag requires that the tag SEARCHENGINE is set to YES.

	SERVER_BASED_SEARCH = NO

	# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
	# script for searching. Instead the search results are written to an XML file
	# which needs to be processed by an external indexer. Doxygen will invoke an
	# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
	# search results.
	#
	# Doxygen ships with an example indexer (doxyindexer) and search engine
	# (doxysearch.cgi) which are based on the open source search engine library
	# Xapian (see: http://xapian.org/).
	#
	# See the section "External Indexing and Searching" for details.
	# The default value is: NO.
	# This tag requires that the tag SEARCHENGINE is set to YES.

	EXTERNAL_SEARCH = NO

	# The SEARCHENGINE_URL should point to a search engine hosted by a web server
	# which will return the search results when EXTERNAL_SEARCH is enabled.
	#
	# Doxygen ships with an example indexer (doxyindexer) and search engine
	# (doxysearch.cgi) which are based on the open source search engine library
	# Xapian (see: http://xapian.org/). See the section "External Indexing and
	# Searching" for details.
	# This tag requires that the tag SEARCHENGINE is set to YES.

	SEARCHENGINE_URL =

	# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
	# search data is written to a file for indexing by an external tool. With the
	# SEARCHDATA_FILE tag the name of this file can be specified.
	# The default file is: searchdata.xml.
	# This tag requires that the tag SEARCHENGINE is set to YES.

	SEARCHDATA_FILE = searchdata.xml

	# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
	# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
	# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
	# projects and redirect the results back to the right project.
	# This tag requires that the tag SEARCHENGINE is set to YES.

	EXTERNAL_SEARCH_ID =

	# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
	# projects other than the one defined by this configuration file, but that are
	# all added to the same external search index. Each project needs to have a
	# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
	# to a relative location where the documentation can be found. The format is:
	# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
	# This tag requires that the tag SEARCHENGINE is set to YES.

	EXTRA_SEARCH_MAPPINGS =

	#---------------------------------------------------------------------------
	# Configuration options related to the LaTeX output
	#---------------------------------------------------------------------------

	# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
	# The default value is: YES.

	GENERATE_LATEX = YES

	# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
	# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
	# it.
	# The default directory is: latex.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_OUTPUT = latex

	# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
	# invoked.
	#
	# Note that when enabling USE_PDFLATEX this option is only used for generating
	# bitmaps for formulas in the HTML output, but not in the Makefile that is
	# written to the output directory.
	# The default file is: latex.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_CMD_NAME = latex

	# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
	# index for LaTeX.
	# The default file is: makeindex.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	MAKEINDEX_CMD_NAME = makeindex

	# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
	# documents. This may be useful for small projects and may help to save some
	# trees in general.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	COMPACT_LATEX = YES

	# The PAPER_TYPE tag can be used to set the paper type that is used by the
	# printer.
	# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
	# 14 inches) and executive (7.25 x 10.5 inches).
	# The default value is: a4.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	PAPER_TYPE = a4

	# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
	# that should be included in the LaTeX output. The package can be specified just
	# by its name or with the correct syntax as to be used with the LaTeX
	# \usepackage command. To get the times font for instance you can specify :
	# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
	# To use the option intlimits with the amsmath package you can specify:
	# EXTRA_PACKAGES=[intlimits]{amsmath}
	# If left blank no extra packages will be included.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	EXTRA_PACKAGES = lmodern,multicol,amsmath

	# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
	# generated LaTeX document. The header should contain everything until the first
	# chapter. If it is left blank doxygen will generate a standard header. See
	# section "Doxygen usage" for information on how to let doxygen write the
	# default header to a separate file.
	#
	# Note: Only use a user-defined header if you know what you are doing! The
	# following commands have a special meaning inside the header: $title,
	# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
	# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
	# string, for the replacement values of the other commands the user is referred
	# to HTML_HEADER.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_HEADER =

	# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
	# generated LaTeX document. The footer should contain everything after the last
	# chapter. If it is left blank doxygen will generate a standard footer. See
	# LATEX_HEADER for more information on how to generate a default footer and what
	# special commands can be used inside the footer.
	#
	# Note: Only use a user-defined footer if you know what you are doing!
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_FOOTER =

	# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
	# LaTeX style sheets that are included after the standard style sheets created
	# by doxygen. Using this option one can overrule certain style aspects. Doxygen
	# will copy the style sheet files to the output directory.
	# Note: The order of the extra style sheet files is of importance (e.g. the last
	# style sheet in the list overrules the setting of the previous ones in the
	# list).
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_EXTRA_STYLESHEET =

	# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
	# other source files which should be copied to the LATEX_OUTPUT output
	# directory. Note that the files will be copied as-is; there are no commands or
	# markers available.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_EXTRA_FILES = doc/lpair_kinematics.pdf \
	doc/cepgen_logo.pdf

	# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
	# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
	# contain links (just like the HTML output) instead of page references. This
	# makes the output suitable for online browsing using a PDF viewer.
	# The default value is: YES.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	PDF_HYPERLINKS = YES

	# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
	# the PDF file directly from the LaTeX files. Set this option to YES, to get a
	# higher quality PDF documentation.
	# The default value is: YES.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	USE_PDFLATEX = YES

	# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
	# command to the generated LaTeX files. This will instruct LaTeX to keep running
	# if errors occur, instead of asking the user for help. This option is also used
	# when generating formulas in HTML.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_BATCHMODE = NO

	# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
	# index chapters (such as File Index, Compound Index, etc.) in the output.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_HIDE_INDICES = NO

	# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
	# code with syntax highlighting in the LaTeX output.
	#
	# Note that which sources are shown also depends on other settings such as
	# SOURCE_BROWSER.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_SOURCE_CODE = YES

	# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
	# bibliography, e.g. plainnat, or ieeetr. See
	# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
	# The default value is: plain.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_BIB_STYLE = plain

	# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
	# page will contain the date and time when the page was generated. Setting this
	# to NO can help when comparing the output of multiple runs.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_LATEX is set to YES.

	LATEX_TIMESTAMP = NO

	#---------------------------------------------------------------------------
	# Configuration options related to the RTF output
	#---------------------------------------------------------------------------

	# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
	# RTF output is optimized for Word 97 and may not look too pretty with other RTF
	# readers/editors.
	# The default value is: NO.

	GENERATE_RTF = NO

	# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
	# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
	# it.
	# The default directory is: rtf.
	# This tag requires that the tag GENERATE_RTF is set to YES.

	RTF_OUTPUT = rtf

	# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
	# documents. This may be useful for small projects and may help to save some
	# trees in general.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_RTF is set to YES.

	COMPACT_RTF = NO

	# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
	# contain hyperlink fields. The RTF file will contain links (just like the HTML
	# output) instead of page references. This makes the output suitable for online
	# browsing using Word or some other Word compatible readers that support those
	# fields.
	#
	# Note: WordPad (write) and others do not support links.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_RTF is set to YES.

	RTF_HYPERLINKS = NO

	# Load stylesheet definitions from file. Syntax is similar to doxygen's config
	# file, i.e. a series of assignments. You only have to provide replacements,
	# missing definitions are set to their default value.
	#
	# See also section "Doxygen usage" for information on how to generate the
	# default style sheet that doxygen normally uses.
	# This tag requires that the tag GENERATE_RTF is set to YES.

	RTF_STYLESHEET_FILE =

	# Set optional variables used in the generation of an RTF document. Syntax is
	# similar to doxygen's config file. A template extensions file can be generated
	# using doxygen -e rtf extensionFile.
	# This tag requires that the tag GENERATE_RTF is set to YES.

	RTF_EXTENSIONS_FILE =

	# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
	# with syntax highlighting in the RTF output.
	#
	# Note that which sources are shown also depends on other settings such as
	# SOURCE_BROWSER.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_RTF is set to YES.

	RTF_SOURCE_CODE = NO

	#---------------------------------------------------------------------------
	# Configuration options related to the man page output
	#---------------------------------------------------------------------------

	# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
	# classes and files.
	# The default value is: NO.

	GENERATE_MAN = NO

	# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
	# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
	# it. A directory man3 will be created inside the directory specified by
	# MAN_OUTPUT.
	# The default directory is: man.
	# This tag requires that the tag GENERATE_MAN is set to YES.

	MAN_OUTPUT = man

	# The MAN_EXTENSION tag determines the extension that is added to the generated
	# man pages. In case the manual section does not start with a number, the number
	# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
	# optional.
	# The default value is: .3.
	# This tag requires that the tag GENERATE_MAN is set to YES.

	MAN_EXTENSION = .3

	# The MAN_SUBDIR tag determines the name of the directory created within
	# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
	# MAN_EXTENSION with the initial . removed.
	# This tag requires that the tag GENERATE_MAN is set to YES.

	MAN_SUBDIR =

	# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
	# will generate one additional man file for each entity documented in the real
	# man page(s). These additional files only source the real man page, but without
	# them the man command would be unable to find the correct page.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_MAN is set to YES.

	MAN_LINKS = NO

	#---------------------------------------------------------------------------
	# Configuration options related to the XML output
	#---------------------------------------------------------------------------

	# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
	# captures the structure of the code including all documentation.
	# The default value is: NO.

	GENERATE_XML = NO

	# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
	# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
	# it.
	# The default directory is: xml.
	# This tag requires that the tag GENERATE_XML is set to YES.

	XML_OUTPUT = xml

	# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
	# listings (including syntax highlighting and cross-referencing information) to
	# the XML output. Note that enabling this will significantly increase the size
	# of the XML output.
	# The default value is: YES.
	# This tag requires that the tag GENERATE_XML is set to YES.

	XML_PROGRAMLISTING = YES

	#---------------------------------------------------------------------------
	# Configuration options related to the DOCBOOK output
	#---------------------------------------------------------------------------

	# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
	# that can be used to generate PDF.
	# The default value is: NO.

	GENERATE_DOCBOOK = NO

	# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
	# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
	# front of it.
	# The default directory is: docbook.
	# This tag requires that the tag GENERATE_DOCBOOK is set to YES.

	DOCBOOK_OUTPUT = docbook

	# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
	# program listings (including syntax highlighting and cross-referencing
	# information) to the DOCBOOK output. Note that enabling this will significantly
	# increase the size of the DOCBOOK output.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_DOCBOOK is set to YES.

	DOCBOOK_PROGRAMLISTING = NO

	#---------------------------------------------------------------------------
	# Configuration options for the AutoGen Definitions output
	#---------------------------------------------------------------------------

	# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
	# AutoGen Definitions (see http://autogen.sf.net) file that captures the
	# structure of the code including all documentation. Note that this feature is
	# still experimental and incomplete at the moment.
	# The default value is: NO.

	GENERATE_AUTOGEN_DEF = NO

	#---------------------------------------------------------------------------
	# Configuration options related to the Perl module output
	#---------------------------------------------------------------------------

	# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
	# file that captures the structure of the code including all documentation.
	#
	# Note that this feature is still experimental and incomplete at the moment.
	# The default value is: NO.

	GENERATE_PERLMOD = NO

	# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
	# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
	# output from the Perl module output.
	# The default value is: NO.
	# This tag requires that the tag GENERATE_PERLMOD is set to YES.

	PERLMOD_LATEX = NO

	# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
	# formatted so it can be parsed by a human reader. This is useful if you want to
	# understand what is going on. On the other hand, if this tag is set to NO, the
	# size of the Perl module output will be much smaller and Perl will parse it
	# just the same.
	# The default value is: YES.
	# This tag requires that the tag GENERATE_PERLMOD is set to YES.

	PERLMOD_PRETTY = YES

	# The names of the make variables in the generated doxyrules.make file are
	# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
	# so different doxyrules.make files included by the same Makefile don't
	# overwrite each other's variables.
	# This tag requires that the tag GENERATE_PERLMOD is set to YES.

	PERLMOD_MAKEVAR_PREFIX =

	#---------------------------------------------------------------------------
	# Configuration options related to the preprocessor
	#---------------------------------------------------------------------------

	# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
	# C-preprocessor directives found in the sources and include files.
	# The default value is: YES.

	ENABLE_PREPROCESSING = YES

	# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
	# in the source code. If set to NO, only conditional compilation will be
	# performed. Macro expansion can be done in a controlled way by setting
	# EXPAND_ONLY_PREDEF to YES.
	# The default value is: NO.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	MACRO_EXPANSION = NO

	# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
	# the macro expansion is limited to the macros specified with the PREDEFINED and
	# EXPAND_AS_DEFINED tags.
	# The default value is: NO.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	EXPAND_ONLY_PREDEF = NO

	# If the SEARCH_INCLUDES tag is set to YES, the include files in the
	# INCLUDE_PATH will be searched if a #include is found.
	# The default value is: YES.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	SEARCH_INCLUDES = YES

	# The INCLUDE_PATH tag can be used to specify one or more directories that
	# contain include files that are not input files but should be processed by the
	# preprocessor.
	# This tag requires that the tag SEARCH_INCLUDES is set to YES.

	INCLUDE_PATH =

	# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
	# patterns (like .h and .hpp) to filter out the header-files in the
	# directories. If left blank, the patterns specified with FILE_PATTERNS will be
	# used.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	INCLUDE_FILE_PATTERNS =

	# The PREDEFINED tag can be used to specify one or more macro names that are
	# defined before the preprocessor is started (similar to the -D option of e.g.
	# gcc). The argument of the tag is a list of macros of the form: name or
	# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
	# is assumed. To prevent a macro definition from being undefined via #undef or
	# recursively expanded use the := operator instead of the = operator.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	PREDEFINED =

	# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
	# tag can be used to specify a list of macro names that should be expanded. The
	# macro definition that is found in the sources will be used. Use the PREDEFINED
	# tag if you want to use a different macro definition that overrules the
	# definition found in the source code.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	EXPAND_AS_DEFINED =

	# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
	# remove all references to function-like macros that are alone on a line, have
	# an all uppercase name, and do not end with a semicolon. Such function macros
	# are typically used for boiler-plate code, and will confuse the parser if not
	# removed.
	# The default value is: YES.
	# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.

	SKIP_FUNCTION_MACROS = YES

	#---------------------------------------------------------------------------
	# Configuration options related to external references
	#---------------------------------------------------------------------------

	# The TAGFILES tag can be used to specify one or more tag files. For each tag
	# file the location of the external documentation should be added. The format of
	# a tag file without this location is as follows:
	# TAGFILES = file1 file2 ...
	# Adding location for the tag files is done as follows:
	# TAGFILES = file1=loc1 "file2 = loc2" ...
	# where loc1 and loc2 can be relative or absolute paths or URLs. See the
	# section "Linking to external documentation" for more information about the use
	# of tag files.
	# Note: Each tag file must have a unique name (where the name does NOT include
	# the path). If a tag file is not located in the directory in which doxygen is
	# run, you must also specify the path to the tagfile here.

	TAGFILES =

	# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
	# tag file that is based on the input files it reads. See section "Linking to
	# external documentation" for more information about the usage of tag files.

	GENERATE_TAGFILE =

	# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
	# the class index. If set to NO, only the inherited external classes will be
	# listed.
	# The default value is: NO.

	ALLEXTERNALS = NO

	# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
	# in the modules index. If set to NO, only the current project's groups will be
	# listed.
	# The default value is: YES.

	EXTERNAL_GROUPS = YES

	# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
	# the related pages index. If set to NO, only the current project's pages will
	# be listed.
	# The default value is: YES.

	EXTERNAL_PAGES = YES

	# The PERL_PATH should be the absolute path and name of the perl script
	# interpreter (i.e. the result of 'which perl').
	# The default file (with absolute path) is: /usr/bin/perl.

	PERL_PATH = /usr/bin/perl

	#---------------------------------------------------------------------------
	# Configuration options related to the dot tool
	#---------------------------------------------------------------------------

	# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
	# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
	# NO turns the diagrams off. Note that this option also works with HAVE_DOT
	# disabled, but it is recommended to install and use dot, since it yields more
	# powerful graphs.
	# The default value is: YES.

	-CLASS_DIAGRAMS = NO
	+CLASS_DIAGRAMS = YES

	# You can define message sequence charts within doxygen comments using the \msc
	# command. Doxygen will then run the mscgen tool (see:
	# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
	# documentation. The MSCGEN_PATH tag allows you to specify the directory where
	# the mscgen tool resides. If left empty the tool is assumed to be found in the
	# default search path.

	MSCGEN_PATH =

	# You can include diagrams made with dia in doxygen documentation. Doxygen will
	# then run dia to produce the diagram and insert it in the documentation. The
	# DIA_PATH tag allows you to specify the directory where the dia binary resides.
	# If left empty dia is assumed to be found in the default search path.

	DIA_PATH =

	# If set to YES the inheritance and collaboration graphs will hide inheritance
	# and usage relations if the target is undocumented or is not a class.
	# The default value is: YES.

	HIDE_UNDOC_RELATIONS = NO

	# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
	# available from the path. This tool is part of Graphviz (see:
	# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
	# Bell Labs. The other options in this section have no effect if this option is
	# set to NO
	# The default value is: NO.

	HAVE_DOT = YES

	# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
	# to run in parallel. When set to 0 doxygen will base this on the number of
	# processors available in the system. You can set it explicitly to a value
	# larger than 0 to get control over the balance between CPU load and processing
	# speed.
	# Minimum value: 0, maximum value: 32, default value: 0.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_NUM_THREADS = 0

	# When you want a differently looking font in the dot files that doxygen
	# generates you can specify the font name using DOT_FONTNAME. You need to make
	# sure dot is able to find the font, which can be done by putting it in a
	# standard location or by setting the DOTFONTPATH environment variable or by
	# setting DOT_FONTPATH to the directory containing the font.
	# The default value is: Helvetica.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_FONTNAME = Verdana

	# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
	# dot graphs.
	# Minimum value: 4, maximum value: 24, default value: 10.
	# This tag requires that the tag HAVE_DOT is set to YES.

	-DOT_FONTSIZE = 8
	+DOT_FONTSIZE = 7

	# By default doxygen will tell dot to use the default font as specified with
	# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
	# the path where dot can find it using this tag.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_FONTPATH =

	# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
	# each documented class showing the direct and indirect inheritance relations.
	# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	CLASS_GRAPH = YES

	# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
	# graph for each documented class showing the direct and indirect implementation
	# dependencies (inheritance, containment, and class references variables) of the
	# class with other documented classes.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	COLLABORATION_GRAPH = YES

	# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
	# groups, showing the direct groups dependencies.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	GROUP_GRAPHS = YES

	# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
	# collaboration diagrams in a style similar to the OMG's Unified Modeling
	# Language.
	# The default value is: NO.
	# This tag requires that the tag HAVE_DOT is set to YES.

	-UML_LOOK = YES
	+UML_LOOK = NO

	# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
	# class node. If there are many fields or methods and many nodes the graph may
	# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
	# number of items for each type to make the size more manageable. Set this to 0
	# for no limit. Note that the threshold may be exceeded by 50% before the limit
	# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
	# but if the number exceeds 15, the total amount of fields shown is limited to
	# 10.
	# Minimum value: 0, maximum value: 100, default value: 10.
	# This tag requires that the tag HAVE_DOT is set to YES.

	UML_LIMIT_NUM_FIELDS = 10

	# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
	# collaboration graphs will show the relations between templates and their
	# instances.
	# The default value is: NO.
	# This tag requires that the tag HAVE_DOT is set to YES.

	TEMPLATE_RELATIONS = NO

	# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
	# YES then doxygen will generate a graph for each documented file showing the
	# direct and indirect include dependencies of the file with other documented
	# files.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	-INCLUDE_GRAPH = NO
	+INCLUDE_GRAPH = YES

	# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
	# set to YES then doxygen will generate a graph for each documented file showing
	# the direct and indirect include dependencies of the file with other documented
	# files.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	INCLUDED_BY_GRAPH = YES

	# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
	# dependency graph for every global function or class method.
	#
	# Note that enabling this option will significantly increase the time of a run.
	# So in most cases it will be better to enable call graphs for selected
	# functions only using the \callgraph command. Disabling a call graph can be
	# accomplished by means of the command \hidecallgraph.
	# The default value is: NO.
	# This tag requires that the tag HAVE_DOT is set to YES.

	-CALL_GRAPH = YES
	+CALL_GRAPH = NO

	# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
	# dependency graph for every global function or class method.
	#
	# Note that enabling this option will significantly increase the time of a run.
	# So in most cases it will be better to enable caller graphs for selected
	# functions only using the \callergraph command. Disabling a caller graph can be
	# accomplished by means of the command \hidecallergraph.
	# The default value is: NO.
	# This tag requires that the tag HAVE_DOT is set to YES.

	CALLER_GRAPH = NO

	# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
	# hierarchy of all classes instead of a textual one.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	GRAPHICAL_HIERARCHY = YES

	# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
	# dependencies a directory has on other directories in a graphical way. The
	# dependency relations are determined by the #include relations between the
	# files in the directories.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DIRECTORY_GRAPH = YES

	# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
	# generated by dot. For an explanation of the image formats see the section
	# output formats in the documentation of the dot tool (Graphviz (see:
	# http://www.graphviz.org/)).
	# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
	# to make the SVG files visible in IE 9+ (other browsers do not have this
	# requirement).
	# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
	# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
	# png:gdiplus:gdiplus.
	# The default value is: png.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_IMAGE_FORMAT = svg

	# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
	# enable generation of interactive SVG images that allow zooming and panning.
	#
	# Note that this requires a modern browser other than Internet Explorer. Tested
	# and working are Firefox, Chrome, Safari, and Opera.
	# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
	# the SVG files visible. Older versions of IE do not have SVG support.
	# The default value is: NO.
	# This tag requires that the tag HAVE_DOT is set to YES.

	-INTERACTIVE_SVG = YES
	+INTERACTIVE_SVG = NO

	# The DOT_PATH tag can be used to specify the path where the dot tool can be
	# found. If left blank, it is assumed the dot tool can be found in the path.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_PATH =

	# The DOTFILE_DIRS tag can be used to specify one or more directories that
	# contain dot files that are included in the documentation (see the \dotfile
	# command).
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOTFILE_DIRS =

	# The MSCFILE_DIRS tag can be used to specify one or more directories that
	# contain msc files that are included in the documentation (see the \mscfile
	# command).

	MSCFILE_DIRS =

	# The DIAFILE_DIRS tag can be used to specify one or more directories that
	# contain dia files that are included in the documentation (see the \diafile
	# command).

	DIAFILE_DIRS =

	# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
	# path where java can find the plantuml.jar file. If left blank, it is assumed
	# PlantUML is not used or called during a preprocessing step. Doxygen will
	# generate a warning when it encounters a \startuml command in this case and
	# will not generate output for the diagram.

	PLANTUML_JAR_PATH =

	# When using plantuml, the specified paths are searched for files specified by
	# the !include statement in a plantuml block.

	PLANTUML_INCLUDE_PATH =

	# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
	# that will be shown in the graph. If the number of nodes in a graph becomes
	# larger than this value, doxygen will truncate the graph, which is visualized
	# by representing a node as a red box. Note that doxygen if the number of direct
	# children of the root node in a graph is already larger than
	# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
	# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
	# Minimum value: 0, maximum value: 10000, default value: 50.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_GRAPH_MAX_NODES = 50

	# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
	# generated by dot. A depth value of 3 means that only nodes reachable from the
	# root by following a path via at most 3 edges will be shown. Nodes that lay
	# further from the root node will be omitted. Note that setting this option to 1
	# or 2 may greatly reduce the computation time needed for large code bases. Also
	# note that the size of a graph can be further restricted by
	# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
	# Minimum value: 0, maximum value: 1000, default value: 0.
	# This tag requires that the tag HAVE_DOT is set to YES.

	-MAX_DOT_GRAPH_DEPTH = 1
	+MAX_DOT_GRAPH_DEPTH = 0

	# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
	# background. This is disabled by default, because dot on Windows does not seem
	# to support this out of the box.
	#
	# Warning: Depending on the platform used, enabling this option may lead to
	# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
	# read).
	# The default value is: NO.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_TRANSPARENT = YES

	# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
	# files in one run (i.e. multiple -o and -T options on the command line). This
	# makes dot run faster, but since only newer versions of dot (>1.8.10) support
	# this, this feature is disabled by default.
	# The default value is: NO.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_MULTI_TARGETS = YES

	# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
	# explaining the meaning of the various boxes and arrows in the dot generated
	# graphs.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	GENERATE_LEGEND = YES

	# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
	# files that are used to generate the various graphs.
	# The default value is: YES.
	# This tag requires that the tag HAVE_DOT is set to YES.

	DOT_CLEANUP = YES
	diff --git a/cepgen-lhe.cpp b/cepgen-lhe.cpp
	index 63ffaaf..d439789 100644
	--- a/cepgen-lhe.cpp
	+++ b/cepgen-lhe.cpp
	@@ -1,60 +1,60 @@
	#include <iostream>

	#include "core/MCGen.h"
	#include "export/EventWriter.h"
	#include "HepMC/Version.h"

	using namespace std;

	/**
	* Main caller for this Monte Carlo generator. Loads the configuration files'
	* variables if set as an argument to this program, else loads a default
	* "LHC-like" configuration, then launches the cross-section computation and
	* the events generation.
	* \author Laurent Forthomme <laurent.forthomme@cern.ch>
	*/
	int main( int argc, char* argv[] ) {
	MCGen mg;

	if ( argc==1 ) InError( "No config file provided." );

	Debugging( Form( "Reading config file stored in %s", argv[1] ) );
	if ( !mg.parameters->ReadConfigFile( argv[1] ) ) {
	Information( Form( "Error reading the configuration!\n\t"
	"Please check your input file (%s)", argv[1] ) );
	return -1;
	}

	// We might want to cross-check visually the validity of our run
	mg.parameters->Dump();

	// Let there be cross-section...
	double xsec, err;
	mg.ComputeXsection( &xsec, &err );

	if ( !mg.parameters->generation ) return 0;

	- EventWriter writer( OutputHandler::ExportHandler::HepMC, "example.dat" );
	+ OutputHandler::EventWriter writer( OutputHandler::ExportHandler::HepMC, "example.dat" );
	writer.SetCrossSection( xsec, err );

	#ifndef HEPMC_VERSION_CODE
	//#error "Hahaha"
	cout << "HepMC version: " << HepMC::versionName() << endl;
	#else
	cout << "HepMC version: " << HepMC::version() << endl;
	//cout << HEPMC_VERSION << endl;
	#endif

	// The events generation starts here !
	for ( unsigned int i=0; i<mg.parameters->maxgen; i++ ) {
	if ( i%10000==0 )
	cout << "Generating event #" << i+1 << endl;
	const Event* ev = mg.GenerateOneEvent();
	writer << ev;
	}

	//mg.parameters->StoreConfigFile( "lastrun.card" );

	return 0;
	}

	diff --git a/export/EventWriter.cpp b/export/EventWriter.cpp
	index 76acc5b..68441bf 100644
	--- a/export/EventWriter.cpp
	+++ b/export/EventWriter.cpp
	@@ -1,34 +1,34 @@
	#include "EventWriter.h"

	-EventWriter::EventWriter( const OutputHandler::ExportHandler::OutputType& type, const char* filename ) :
	+OutputHandler::EventWriter::EventWriter( const OutputHandler::ExportHandler::OutputType& type, const char* filename ) :
	fFileHandler( 0 ), fType( type )
	{
	switch ( fType ) {
	#ifdef HEPMC_LINKED
	case OutputHandler::ExportHandler::HepMC: { fFileHandler = new OutputHandler::HepMCHandler( filename ); } break;
	case OutputHandler::ExportHandler::LHE: { fFileHandler = new OutputHandler::LHEFHandler( filename ); } break;
	#endif
	default: return;
	}
	}

	-EventWriter::~EventWriter()
	+OutputHandler::EventWriter::~EventWriter()
	{
	// HepMC persistent objects
	if ( fFileHandler ) delete fFileHandler;
	}

	void
	-EventWriter::operator<<( const Event* evt )
	+OutputHandler::EventWriter::operator<<( const Event* evt )
	{
	switch ( fType ) {
	#ifdef HEPMC_LINKED
	case OutputHandler::ExportHandler::HepMC:
	case OutputHandler::ExportHandler::LHE: {
	(*fFileHandler) << evt;
	} break;
	#endif
	default: return;
	}
	}

	diff --git a/export/EventWriter.h b/export/EventWriter.h
	index 15de77a..3c26aa0 100644
	--- a/export/EventWriter.h
	+++ b/export/EventWriter.h
	@@ -1,39 +1,54 @@
	#ifndef EventWriter_h
	#define EventWriter_h

	#include "physics/Event.h"
	#include "export/ExportHandler.h"

	#ifdef HEPMC_LINKED
	#include "export/HepMCHandler.h"
	#include "export/LHEFHandler.h"
	#endif

	-class EventWriter
	+namespace OutputHandler
	{
	- public:
	-
	- EventWriter( const OutputHandler::ExportHandler::OutputType&, const char* );
	- ~EventWriter();
	-
	- void SetCrossSection( const float& xsec, const float& err_xsec ) {
	-#ifdef HEPMC_LINKED
	- if ( fFileHandler ) fFileHandler->SetCrossSection( xsec, err_xsec );
	-#endif
	- }
	- void SetEventNumber( const unsigned int& ev_id ) {
	-#ifdef HEPMC_LINKED
	- if ( fFileHandler ) fFileHandler->SetEventNumber( ev_id );
	-#endif
	- }
	-
	- void operator<<( const Event* );
	-
	- private:
	-
	- OutputHandler::ExportHandler* fFileHandler;
	- OutputHandler::ExportHandler::OutputType fType;
	-
	-};
	+ /**
	+ * \brief Generic events dumper
	+ * \author Laurent Forthomme <laurent.forthomme@cern.ch>
	+ * \date Sep 2016
	+ */
	+ class EventWriter
	+ {
	+ public:
	+
	+ /// Class constructor
	+ /// \param[in] type Requested output type
	+ /// \param[in] filename Output file path
	+ EventWriter( const OutputHandler::ExportHandler::OutputType& type, const char* filename );
	+ ~EventWriter();
	+
	+ /// Specify the process cross section and its associated error
	+ void SetCrossSection( const float& xsec, const float& err_xsec ) {
	+ #ifdef HEPMC_LINKED
	+ if ( fFileHandler ) fFileHandler->SetCrossSection( xsec, err_xsec );
	+ #endif
	+ }
	+ /// Specify the event number
	+ void SetEventNumber( const unsigned int& ev_id ) {
	+ #ifdef HEPMC_LINKED
	+ if ( fFileHandler ) fFileHandler->SetEventNumber( ev_id );
	+ #endif
	+ }
	+ /// Writer operator
	+ void operator<<( const Event* );
	+
	+ private:
	+
	+ /// Inherited file handler
	+ OutputHandler::ExportHandler* fFileHandler;
	+ /// Type of output requested
	+ OutputHandler::ExportHandler::OutputType fType;
	+
	+ };
	+}

	#endif
	diff --git a/export/ExportHandler.h b/export/ExportHandler.h
	index b239241..049d20f 100644
	--- a/export/ExportHandler.h
	+++ b/export/ExportHandler.h
	@@ -1,36 +1,49 @@
	#ifndef OutputHandler_ExportHandler_h
	#define OutputHandler_ExportHandler_h

	#include "physics/Event.h"

	namespace OutputHandler
	{
	+ /**
	+ * \brief Output format handler for events export
	+ * \author Laurent Forthomme <laurent.forthomme@cern.ch>
	+ * \date Sep 2016
	+ */
	class ExportHandler
	{
	public:
	-
	+ /// All types of output available for export
	enum OutputType {
	HepMC, LHE
	};

	public:
	+ /// Class constructor
	+ /// \param[in] type Requested output type
	ExportHandler( const OutputType& type ) : fType( type ) {;}
	virtual ~ExportHandler() {;}
	-
	+ /// Set the process cross section and its associated error
	void SetCrossSection( const float& xsec, const float& err_xsec ) {
	fCrossSect = xsec;
	fCrossSectErr = err_xsec;
	}
	+ /// Set the event number
	void SetEventNumber( const unsigned int& ev_id ) { fEventNum = ev_id; }
	+ /// Writer operator
	virtual void operator<<( const Event* ) {;}

	protected:
	-
	+ /// Type of output requested
	OutputType fType;
	- float fCrossSect, fCrossSectErr;
	+ /// Process cross section
	+ float fCrossSect;
	+ /// Error on process cross section
	+ float fCrossSectErr;
	+ /// Event number in generation
	unsigned int fEventNum;

	};
	}

	#endif
	diff --git a/export/HepMCHandler.h b/export/HepMCHandler.h
	index 4669ab6..1aaf8c3 100644
	--- a/export/HepMCHandler.h
	+++ b/export/HepMCHandler.h
	@@ -1,52 +1,60 @@
	#ifndef OutputHandler_HepMCHandler_h
	#define OutputHandler_HepMCHandler_h

	#include "export/ExportHandler.h"

	#include "HepMC/Version.h"

	#ifndef HEPMC_VERSION_CODE
	#include "HepMC/IO_GenEvent.h"
	#else
	#include "HepMC/WriterAscii.h"
	#endif

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

	namespace OutputHandler
	{
	/**
	* \brief Handler for the HepMC file output
	* \author Laurent Forthomme <laurent.forthomme@cern.ch>
	* \date Sep 2016
	*/
	class HepMCHandler : public ExportHandler
	{
	public:
	-
	- HepMCHandler( const char* );
	+ /// Class constructor
	+ /// \param[in] filename Output file path
	+ HepMCHandler( const char* filename );
	~HepMCHandler();
	+ /// Writer operator
	void operator<<( const Event* );

	private:
	-
	+ /// Clear the associated HepMC event content
	inline void clearEvent();
	+ /// Populate the associated HepMC event with a Event object
	void fillEvent( const Event* );

	#ifndef HEPMC_VERSION_CODE
	+ /// Writer object (from HepMC v>=3)
	HepMC::IO_GenEvent* output;
	#else
	+ /// Writer object (from HepMC v<3)
	HepMC::WriterAscii* output;
	#endif
	+ /// Associated HepMC event
	HepMC::GenEvent* event;
	+ /// List of particles in the event
	std::vector<HepMC::GenParticle*> particles;
	+ /// List of vertices in the event
	std::vector<HepMC::GenVertex*> vertices;

	};

	}

	#endif
	diff --git a/export/LHEFHandler.cpp b/export/LHEFHandler.cpp
	index 0bed291..af2c4db 100644
	--- a/export/LHEFHandler.cpp
	+++ b/export/LHEFHandler.cpp
	@@ -1,33 +1,40 @@
	#include "LHEFHandler.h"

	-OutputHandler::LHEFHandler::LHEFHandler( const char* filename ) :
	- ExportHandler( ExportHandler::LHE )
	-{
	- output = new LHEF::Writer(filename);
	-}
	+#if HEPMC_VERSION_CODE>=3000000

	-void
	-OutputHandler::LHEFHandler::operator<<( const Event* ev )
	+namespace OutputHandler
	{
	- fillEvent(ev);
	- output->writeEvent();
	- clearEvent();
	-}
	+ LHEFHandler::LHEFHandler( const char* filename ) :
	+ ExportHandler( ExportHandler::LHE )
	+ {
	+ output = new LHEF::Writer(filename);
	+ }

	-void
	-OutputHandler::LHEFHandler::fillEvent( const Event* ev )
	-{
	- // ... do whatever is needed for output->hepeup
	- ConstParticlesRef part_vec = ev->GetConstParticlesRef();
	- //HEPEUT*
	- for ( unsigned int i=0; i<part_vec.size(); i++ ) {
	-
	+ void
	+ LHEFHandler::operator<<( const Event* ev )
	+ {
	+ fillEvent(ev);
	+ output->writeEvent();
	+ clearEvent();
	}
	-}

	-void
	-OutputHandler::LHEFHandler::clearEvent()
	-{
	- // ...
	- output->hepeup.clear();
	+ void
	+ LHEFHandler::fillEvent( const Event* ev )
	+ {
	+ // ... do whatever is needed for output->hepeup
	+ ConstParticlesRef part_vec = ev->GetConstParticlesRef();
	+ //HEPEUT*
	+ for ( unsigned int i=0; i<part_vec.size(); i++ ) {
	+
	+ }
	+ }
	+
	+ void
	+ LHEFHandler::clearEvent()
	+ {
	+ // ...
	+ output->hepeup.clear();
	+ }
	}
	+
	+#endif
	diff --git a/export/LHEFHandler.h b/export/LHEFHandler.h
	index e0955b5..99e8ad2 100644
	--- a/export/LHEFHandler.h
	+++ b/export/LHEFHandler.h
	@@ -1,38 +1,41 @@
	#ifndef OutputHandler_LHEFHandler_h
	#define OutputHandler_LHEFHandler_h

	#include "export/ExportHandler.h"
	#include "physics/Event.h"

	#include "HepMC/Version.h"

	#if HEPMC_VERSION_CODE>=3000000

	#include "HepMC/LHEF.h"

	namespace OutputHandler
	{
	/**
	* \brief Handler for the LHE file output
	* \author Laurent Forthomme <laurent.forthomme@cern.ch>
	* \date Sep 2016
	*/
	class LHEFHandler : public ExportHandler
	{
	public:
	-
	+ /// Class constructor
	+ /// \param[in] filename Output file path
	LHEFHandler( const char* filename );
	+ /// Writer operator
	void operator<<( const Event* );

	private:
	-
	+ /// Fill the handler with the original Event object
	void fillEvent( const Event* );
	+ /// Remove all references to the original Event object
	void clearEvent();
	-
	+ /// Writer object (from HepMC)
	LHEF::Writer* output;

	};
	}

	#endif
	#endif
	diff --git a/physics/Event.cpp b/physics/Event.cpp
	index 077f24d..281e2e1 100644
	--- a/physics/Event.cpp
	+++ b/physics/Event.cpp
	@@ -1,235 +1,207 @@
	#include "Event.h"

	Event::Event() :
	num_hadronisation_trials( 0 ),
	time_generation( -1. ), time_total( -1. )
	{}

	Event::~Event()
	{}

	Event&
	Event::operator=( const Event &ev_ )
	{
	fParticles = ev_.fParticles;
	time_generation = ev_.time_generation;
	time_total = ev_.time_total;
	num_hadronisation_trials = ev_.num_hadronisation_trials;
	return *this;
	}

	void
	Event::clear()
	{
	fParticles.clear();
	time_generation = -1.;
	time_total = -1.;
	}

	void
	Event::Init()
	{
	fLastParticle = fParticles.end();
	}

	void
	Event::Restore()
	{
	fParticles.erase( fLastParticle, fParticles.end() );
	}

	ParticlesRef
	Event::GetByRole( const Particle::Role& role_ )
	{
	ParticlesRef out;
	std::pair<ParticlesMap::iterator,ParticlesMap::iterator> ret = fParticles.equal_range( role_ );

	unsigned int i = 0;
	for ( ParticlesMap::iterator it=ret.first; it!=ret.second && i<100; it++ ) {
	out.push_back( &( it->second ) );
	i++;
	}
	return out;
	}

	Particle*
	Event::GetById( int id_ )
	{
	for ( ParticlesMap::iterator out=fParticles.begin(); out!=fParticles.end(); out++ ) {
	if ( out->second.id==id_ ) return &out->second;
	}
	return 0;
	}

	const Particle
	Event::GetConstById( int id_ ) const
	{
	for ( ParticlesMap::const_iterator out=fParticles.begin(); out!=fParticles.end(); out++ ) {
	if ( out->second.id==id_ ) return static_cast<Particle>( out->second );
	}
	return Particle();
	}

	ParticleRoles
	Event::GetRoles() const
	{
	ParticleRoles out;
	ParticlesMap::const_iterator it, end;
	for ( it=fParticles.begin(), end=fParticles.end(); it!=end; it=fParticles.upper_bound( it->first ) ) {
	out.push_back( it->first );
	}
	return out;
	}

	int
	Event::AddParticle( Particle part_, bool replace_ )
	{
	DebuggingInsideLoop( Form( "Particle with PDGid = %d has role %d", part_.GetPDGId(), part_.role ) );
	if ( part_.role<=0 ) return -1;

	ParticlesRef part_with_same_role = GetByRole( part_.role );
	part_.id = fParticles.size(); //FIXME is there any better way of introducing this id ?
	if ( replace_ and part_with_same_role.size()!=0 ) {
	part_with_same_role.at( 0 ) = &part_;
	return 0;
	}
	fParticles.insert( std::pair<Particle::Role,Particle>( part_.role, part_ ) );
	return 1;
	}

	int
	Event::AddParticle( const Particle::Role& role_, bool replace_ )
	{
	if ( role_<=0 ) return -1;

	np = new Particle();
	np->role = role_;
	int out = AddParticle( *np, replace_ );

	delete np;
	return out;
	}

	-void
	-Event::Store( std::ofstream *of_, double weight_ )
	-{
	- Particle* l1 = GetOneByRole( Particle::CentralParticle1 ),
	- *l2 = GetOneByRole( Particle::CentralParticle2 );
	-
	- *of_ << std::setw( 8 ) << l1->E() << "\t"
	- << std::setw( 8 ) << l1->GetMomentum().Px() << "\t"
	- << std::setw( 8 ) << l1->GetMomentum().Py() << "\t"
	- << std::setw( 8 ) << l1->GetMomentum().Pz() << "\t"
	- << std::setw( 8 ) << l1->GetMomentum().Pt() << "\t"
	- << std::setw( 8 ) << l1->M() << "\t"
	- << std::setw( 8 ) << l1->GetMomentum().Eta() << "\t"
	- << std::setw( 8 ) << l1->GetPDGId() << "\t"
	- << std::setw( 8 ) << weight_
	- << std::endl;
	- *of_ << std::setw( 8 ) << l2->E() << "\t"
	- << std::setw( 8 ) << l2->GetMomentum().Px() << "\t"
	- << std::setw( 8 ) << l2->GetMomentum().Py() << "\t"
	- << std::setw( 8 ) << l2->GetMomentum().Pz() << "\t"
	- << std::setw( 8 ) << l2->GetMomentum().Pt() << "\t"
	- << std::setw( 8 ) << l2->M() << "\t"
	- << std::setw( 8 ) << l2->GetMomentum().Eta() << "\t"
	- << std::setw( 8 ) << l2->GetPDGId() << "\t"
	- << std::setw( 8 ) << weight_
	- << std::endl;
	-}
	-
	ParticlesRef
	Event::GetParticles()
	{
	ParticlesRef out;
	for ( ParticlesMap::iterator it=fParticles.begin(); it!=fParticles.end(); it++ ) {
	out.push_back( &it->second );
	}
	std::sort( out.begin(), out.end(), compareParticlePtrs );
	return out;
	}

	Particles
	Event::GetConstParticles() const
	{
	Particles out;
	for ( ParticlesMap::const_iterator it=fParticles.begin(); it!=fParticles.end(); it++ ) {
	out.push_back( static_cast<Particle>( it->second ) );
	}
	std::sort( out.begin(), out.end(), compareParticle );
	return out;
	}

	ConstParticlesRef
	Event::GetConstParticlesRef() const
	{
	ConstParticlesRef out;
	for ( ParticlesMap::const_iterator it=fParticles.begin(); it!=fParticles.end(); it++ ) {
	out.push_back( &it->second );
	}
	std::sort( out.begin(), out.end(), compareParticlePtrs );
	return out;
	}

	ParticlesRef
	Event::GetStableParticles()
	{
	ParticlesRef out;
	for ( ParticlesMap::iterator it=fParticles.begin(); it!=fParticles.end(); it++ ) {
	if ( it->second.status==Particle::Undefined
	or it->second.status==Particle::FinalState ) {
	out.push_back( &it->second );
	}
	}
	std::sort( out.begin(), out.end() );
	return out;
	}

	void
	Event::Dump(bool stable_) const
	{
	double pxtot, pytot, pztot, etot;
	std::ostringstream os;

	pxtot = pytot = pztot = etot = 0.;
	const ConstParticlesRef particles = GetConstParticlesRef();
	for ( ConstParticlesRef::const_iterator part_ref=particles.begin(); part_ref!=particles.end(); part_ref++ ) {
	const Particle* p = ( *part_ref );
	if ( stable_ and p->status!=Particle::FinalState ) continue;

	os << Form( "\n %2d\t%+6d", p->id, p->GetIntPDGId() );
	if ( p->name!="" ) os << Form( "%6s", p->name.c_str() );
	//else os << std::setw(6) << Particle::ParticleCode( abs( p->GetPDGId() ) );
	else os << "\t";
	os << "\t";
	if ( p->charge!=999. ) os << Form( "%6.2f\t", p->charge );
	else os << "\t";
	os << Form( "%4d\t%6d\t", p->role, p->status );
	if ( p->GetMothersIds().size()>0 )
	os << Form( "%2d(%2d)", ( p->GetMothersIds().begin() ), GetConstById( ( p->GetMothersIds().begin() ) ).role );
	else
	os << " ";
	os << Form( "% 9.3f % 9.3f % 9.3f % 9.3f", p->GetMomentum().Px(), p->GetMomentum().Py(), p->GetMomentum().Pz(), p->E() );
	if ( p->status==Particle::Undefined
	or p->status==Particle::FinalState
	or p->status==Particle::Undecayed ) {
	const int sign = ( p->status==Particle::Undefined ) ? -1 : 1;
	pxtot += sign*p->GetMomentum().Px();
	pytot += sign*p->GetMomentum().Py();
	pztot += sign*p->GetMomentum().Pz();
	etot += sign*p->E();
	}
	}
	// We set a threshold to the computation precision
	if ( fabs(pxtot)<1.e-12 ) pxtot = 0.;
	if ( fabs(pytot)<1.e-12 ) pytot = 0.;
	if ( fabs(pztot)<1.e-12 ) pztot = 0.;
	if ( fabs( etot)<1.e-12 ) etot = 0.;
	//
	Information( Form( "Dump of event content:\n"
	"Part.\tPDG id\t\tCharge\tRole\tStatus\tMother\t\t4-Momentum (GeV)\n"
	"----\t------\t\t------\t----\t------\t------\t-------------------------------------"
	"%s\n"
	"---------------------------------------------------------------------------------------------\n"
	"Total:\t\t\t\t\t\t % 9.4f % 9.4f % 9.4f % 9.4f", os.str().c_str(), pxtot, pytot, pztot, etot ) );
	}
	diff --git a/physics/Event.h b/physics/Event.h
	index 92d479f..9b2a8da 100644
	--- a/physics/Event.h
	+++ b/physics/Event.h
	@@ -1,161 +1,157 @@
	#ifndef Event_h
	#define Event_h

	#include <vector>
	#include <string>
	#include <fstream>
	#include <iomanip>
	#include <algorithm>

	#include "Particle.h"

	/**
	* Class containing all the information on the in- and outgoing particles' kinematics
	* @brief Kinematic information on the particles in the event
	*/
	class Event {
	public:
	Event();
	~Event();
	/**
	* @brief Copies all the relevant quantities from one Event object to another
	*/
	Event& operator=( const Event& );
	/**
	* @brief Empties the whole event content
	*/
	void clear();
	/// Initialize an "empty" event collection
	void Init();
	/// Restore the event to its "empty" state
	void Restore();
	/**
	* Returns the list of pointers to the Particle objects corresponding to a certain role in the process kinematics
	* @brief Gets a list of particles by their role in the event
	* @param[in] role_ The role the particles have to play in the process
	* @return A vector of pointers to the requested Particle objects
	*/
	ParticlesRef GetByRole( const Particle::Role& role_);
	/**
	* Returns the first Particle object in the particles list whose role corresponds to the given argument
	* @param[in] role_ The role the particle has to play in the event
	* @return A Particle object corresponding to the first particle found in this event
	*/
	inline Particle* GetOneByRole( const Particle::Role& role_ ) {
	ParticlesMap::iterator it = fParticles.find( role_ );
	if ( it!=fParticles.end() ) return &( it->second );
	return 0;
	};
	/**
	* Returns the pointer to the Particle object corresponding to a unique identifier in the event
	* @brief Gets one particle by its unique identifier in the event
	* @param[in] id_ The unique identifier to this particle in the event
	* @return A pointer to the requested Particle object
	*/
	Particle* GetById( int id_ );
	/// Get a const Particle object using its unique identifier
	/// \param[in] id_ Unique identifier of the particle in the event
	/// \return Constant object to be retrieved
	const Particle GetConstById( int id_ ) const;
	/**
	* Returns the pointers to the Particle objects corresponding to the unique identifiers in the event
	* @brief Gets a vector of particles by their unique identifier in the event
	* @param[in] ids_ The unique identifiers to the particles to be selected in the event
	* @return A vector of pointers to the requested Particle objects
	*/
	inline ParticlesRef GetByIds( const ParticlesIds& ids_ ) {
	ParticlesRef out;
	for ( ParticlesIds::const_iterator id=ids_.begin(); id!=ids_.end(); id++ ) {
	out.push_back( GetById( *id ) );
	}
	return out;
	}
	/**
	* Returns the pointer to the mother particle of any given Particle object in this event
	* @param[in] part_ The pointer to the Particle object from which we want to extract the mother particle
	* @return A pointer to the mother Particle object
	*/
	inline ParticlesRef GetMothers( Particle* part_ ) {
	ParticlesRef out;
	const ParticlesIds moth = part_->GetMothersIds();
	for ( ParticlesIds::const_iterator m=moth.begin(); m!=moth.end(); m++ ) {
	out.push_back( GetById( *m ) );
	}
	return out;
	}; // FIXME
	/// Return all const objects representing the mother particles of a given particle
	/// \param[in] part_ Particle object for which the mothers are retrieved
	/// \return Vector of Particle mother objects
	inline Particles GetConstMothers( const Particle* part_ ) const {
	Particles out;
	const ParticlesIds moth = part_->GetMothersIds();
	for ( ParticlesIds::const_iterator m=moth.begin(); m!=moth.end(); m++ ) {
	out.push_back( GetConstById( *m ) );
	}
	return out;
	}; // FIXME
	/// Get a vector containing all the daughters from a particle
	/// \param[in] part_ The particle for which the daughter particles have to be retrieved
	/// \return Vector of Particle objects containing all the daughters' kinematic information
	inline ParticlesRef GetDaughters( const Particle* part_ ) { return GetByIds( part_->GetDaughters() ); };
	/// Get a list of roles for the given event (really process-dependant for the central system)
	/// \return Vector of integers corresponding to all the roles the particles can play in the event
	ParticleRoles GetRoles() const;
	/// Set the information on one particle in the process
	/**
	* \param[in] part_ The Particle object to insert or modify in the event
	* \param[in] replace_ Do we replace the particle if already present in the event or do we append another particle with the same role ?
	* \return
	* * 1 if a new Particle object has been inserted in the event
	* * 0 if an existing Particle object has been modified
	* * -1 if the requested role to edit is undefined or incorrect
	*/
	int AddParticle( Particle part_, bool replace_=false );
	/// Create a new particle in the event, with no kinematic information but the role it has to play in the process
	/**
	* \param[in] role_ The role the particle will play in the process
	* \param[in] replace_ Do we replace the particle if already present in the event or do we append another particle with the same role ?
	* \return
	* * 1 if a new Particle object has been inserted in the event
	* * 0 if an existing Particle object has been modified
	* * -1 if the requested role to edit is undefined or incorrect
	*/
	int AddParticle( const Particle::Role& role_, bool replace_=false );
	- //HEPEUP GetHEPEUP() const;
	- /// Store in a file (raw format) all the kinematics on the outgoing leptons
	- /// \param[in] weight_ Weight of the event
	- void Store( std::ofstream*, double weight_=1. );
	- //void Hadronise(std::string algo_="");
	/// Dump all the known information on every Particle object contained in this Event container in the output stream
	/// \param[in] stable_ Do we only show the stable particles in this event?
	void Dump( bool stable_=false ) const;
	/// Get a vector of all particles in the event
	/// \return Vector containing all the pointers to the Particle objects contained in the event
	ParticlesRef GetParticles();
	/// Get a vector of all particles in the event as const objects
	/// \return Vector containing all the const pointers to the Particle objects contained in the event
	Particles GetConstParticles() const;
	+ /// Get the list of references to const particles contained in the event
	ConstParticlesRef GetConstParticlesRef() const;
	/// Get a vector of all stable particles in the event
	/// \return Vector containing all the pointers to the stable Particle objects contained in the event
	ParticlesRef GetStableParticles();
	/// Number of particles in the event
	/// \return Integer number of particles in the event
	inline unsigned int NumParticles() const { return fParticles.size(); };
	/// Number of trials before the event was "correctly" hadronised
	int num_hadronisation_trials;
	/// Time needed to generate the event at parton level (in seconds)
	float time_generation;
	/// Time needed to generate the hadronised (if needed) event (in seconds)
	float time_total;
	//HEPEUP event_info;
	private:
	/// List of particles in the event, mapped to their role in the process
	ParticlesMap fParticles;
	/// Last particle in an "empty" event
	ParticlesMap::iterator fLastParticle;
	/// Empty particle returned to the get-ers if no particle matches the requirements
	Particle* np;
	};

	#endif
	diff --git a/physics/FormFactors.cpp b/physics/FormFactors.cpp
	index 3125942..53aff1a 100644
	--- a/physics/FormFactors.cpp
	+++ b/physics/FormFactors.cpp
	@@ -1,124 +1,163 @@
	#include "FormFactors.h"

	-// values of a, b, c provided from the fits on ep data and retrieved from
	-// http://dx.doi.org/10.1016/0550-3213(76)90231-5 with 1.110 <= w2 <=1.990
	-
	-double abrass[56] = {5.045,5.126,5.390,5.621,5.913,5.955,6.139,6.178,6.125,5.999,
	- 5.769,5.622,5.431,5.288,5.175,5.131,5.003,5.065,5.045,5.078,
	- 5.145,5.156,5.234,5.298,5.371,5.457,5.543,5.519,5.465,5.384,
	- 5.341,5.320,5.275,5.290,5.330,5.375,5.428,5.478,5.443,5.390,
	- 5.333,5.296,5.223,5.159,5.146,5.143,5.125,5.158,5.159,5.178,
	- 5.182,5.195,5.160,5.195,5.163,5.172};
	-double bbrass[56] = {0.798,1.052,1.213,1.334,1.397,1.727,1.750,1.878,1.887,1.927,
	- 2.041,2.089,2.148,2.205,2.344,2.324,2.535,2.464,2.564,2.610,
	- 2.609,2.678,2.771,2.890,2.982,3.157,3.183,3.315,3.375,3.450,
	- 3.477,3.471,3.554,3.633,3.695,3.804,3.900,4.047,4.290,4.519,
	- 4.709,4.757,4.840,5.017,5.015,5.129,5.285,5.322,5.545,5.623,
	- 5.775,5.894,6.138,6.151,6.301,6.542};
	-double cbrass[56] = { 0.043, 0.024, 0.000,-0.013,-0.023,-0.069,-0.060,-0.080,-0.065,-0.056,
	- -0.065,-0.056,-0.043,-0.034,-0.054,-0.018,-0.046,-0.015,-0.029,-0.048,
	- -0.032,-0.045,-0.084,-0.115,-0.105,-0.159,-0.164,-0.181,-0.203,-0.223,
	- -0.245,-0.254,-0.239,-0.302,-0.299,-0.318,-0.383,-0.393,-0.466,-0.588,
	- -0.622,-0.568,-0.574,-0.727,-0.665,-0.704,-0.856,-0.798,-1.048,-0.980,
	- -1.021,-1.092,-1.313,-1.341,-1.266,-1.473};
	-
	bool
	-PSF(double q2_, double mX2_, double* sigT_, double* w1_, double* w2_)
	+PSF( double q2, double mx2, double* sigma_t, double* w1, double* w2 )
	{
	int nBin;
	double xBin, dx, nu2, logqq0, gd2;
	double sigLow, sigHigh;
	- double mX = sqrt(mX2_);
	+
	//const double m_min = Particle::GetMassFromPDGId(Particle::Proton)+0.135;
	- const double m_min = 1.07, mP = 0.938;
	-
	- if (mX>=m_min && mX<1.99) {
	- if (mX<1.11) {
	- nBin = 0;
	- xBin = mX-m_min;
	- dx = 1.11-m_min; // Delta w bin sizes
	- }
	- else if (mX<1.77) { // w in [1.11, 1.77[
	- dx = 0.015; // Delta w bin sizes
	- nBin = (mX-1.11)/dx+1;
	- xBin = fmod(mX-1.11, dx);
	- }
	- else { // w in [1.77, 1.99[
	- dx = 0.02; // Delta w bin sizes
	- nBin = (mX-1.77)/dx+45;
	- xBin = fmod(mX-1.77, dx);
	- }
	- }
	- else {
	- *sigT_ = 0.;
	- *w1_ = 0.;
	- *w2_ = 0.;
	+ const double m_proton = Particle::GetMassFromPDGId( Particle::Proton ),
	+ m2_proton = m_proton*m_proton,
	+ m_min = m_proton+Particle::GetMassFromPDGId( Particle::PiZero );
	+
	+ const double mx = sqrt( mx2 );
	+
	+ if ( mx<m_min or mx<1.99 ) {
	+ sigma_t = w1 = *w2 = 0.;
	return false;
	}
	- nu2 = pow( ( mX2_-q2_-mPmP ) / ( 2.mP ), 2 );
	- logqq0 = log( ( nu2-q2_ ) / pow( ( mX2_-mPmP ) / ( 2.mP ), 2 ) ) / 2.;
	- gd2 = pow( 1. / ( 1-q2_ / .71 ), 4 ); // dipole form factor of the proton

	- sigLow = (nBin!=0) ?
	- exp( abrass[nBin-1]+bbrass[nBin-1]logqq0+cbrass[nBin-1]pow( fabs( logqq0 ), 3 ) )*gd2 :
	- 0.;
	+ // values of a, b, c provided from the fits on ep data and retrieved from
	+ // http://dx.doi.org/10.1016/0550-3213(76)90231-5 with 1.110 <= w2 <=1.990
	+ const double abrass[56] = { 5.045,5.126,5.390,5.621,5.913,5.955,6.139,6.178,6.125,5.999,
	+ 5.769,5.622,5.431,5.288,5.175,5.131,5.003,5.065,5.045,5.078,
	+ 5.145,5.156,5.234,5.298,5.371,5.457,5.543,5.519,5.465,5.384,
	+ 5.341,5.320,5.275,5.290,5.330,5.375,5.428,5.478,5.443,5.390,
	+ 5.333,5.296,5.223,5.159,5.146,5.143,5.125,5.158,5.159,5.178,
	+ 5.182,5.195,5.160,5.195,5.163,5.172 },
	+ bbrass[56] = { 0.798,1.052,1.213,1.334,1.397,1.727,1.750,1.878,1.887,1.927,
	+ 2.041,2.089,2.148,2.205,2.344,2.324,2.535,2.464,2.564,2.610,
	+ 2.609,2.678,2.771,2.890,2.982,3.157,3.183,3.315,3.375,3.450,
	+ 3.477,3.471,3.554,3.633,3.695,3.804,3.900,4.047,4.290,4.519,
	+ 4.709,4.757,4.840,5.017,5.015,5.129,5.285,5.322,5.545,5.623,
	+ 5.775,5.894,6.138,6.151,6.301,6.542 },
	+ cbrass[56] = { 0.043, 0.024, 0.000,-0.013,-0.023,-0.069,-0.060,-0.080,-0.065,-0.056,
	+ -0.065,-0.056,-0.043,-0.034,-0.054,-0.018,-0.046,-0.015,-0.029,-0.048,
	+ -0.032,-0.045,-0.084,-0.115,-0.105,-0.159,-0.164,-0.181,-0.203,-0.223,
	+ -0.245,-0.254,-0.239,-0.302,-0.299,-0.318,-0.383,-0.393,-0.466,-0.588,
	+ -0.622,-0.568,-0.574,-0.727,-0.665,-0.704,-0.856,-0.798,-1.048,-0.980,
	+ -1.021,-1.092,-1.313,-1.341,-1.266,-1.473 };
	+
	+ if ( mx<1.11 ) {
	+ nBin = 0;
	+ xBin = mx-m_min;
	+ dx = 1.11-m_min; // Delta w bin sizes
	+ }
	+ else if ( mx<1.77 ) { // w in [1.11, 1.77[
	+ dx = 0.015; // Delta w bin sizes
	+ nBin = ( mx-1.11 )/dx + 1;
	+ xBin = fmod( mx-1.11, dx );
	+ }
	+ else { // w in [1.77, 1.99[
	+ dx = 0.02; // Delta w bin sizes
	+ nBin = ( mx-1.77 )/dx + 45;
	+ xBin = fmod( mx-1.77, dx );
	+ }
	+ nu2 = pow( ( mx2-q2-m2_proton ) / ( 2.*m_proton ), 2 );
	+ logqq0 = log( ( nu2-q2 ) / pow( ( mx2-m2_proton ) / ( 2.*m_proton ), 2 ) ) / 2.;
	+ gd2 = pow( 1. / ( 1-q2 / .71 ), 4 ); // dipole form factor of the proton
	+
	+ sigLow = (nBin==0) ? 0. :
	+ exp( abrass[nBin-1]+bbrass[nBin-1]logqq0+cbrass[nBin-1]pow( fabs( logqq0 ), 3 ) )*gd2;
	sigHigh =
	exp( abrass[nBin] +bbrass[nBin] logqq0+cbrass[nBin] pow( fabs( logqq0 ), 3 ) )*gd2;

	- sigT_ = sigLow+xBin(sigHigh-sigLow)/dx;
	- w1_ = ( mX2_-mPmP )/( 8.Constants::PiConstants::PimPConstants::AlphaEM )/Constants::GeV2toBarn1.e6(*sigT_);
	- w2_ = (w1_)*q2_/(q2_-nu2);
	+ sigma_t = sigLow + xBin( sigHigh-sigLow )/dx;
	+ w1 = ( mx2-m2_proton )/( 8.Constants::PiConstants::Pim_protonConstants::AlphaEM )/Constants::GeV2toBarn1.e6(sigma_t);
	+ w2 = ( w1 ) * q2/( q2-nu2 );

	return true;
	}

	FormFactors
	TrivialFormFactors()
	{
	FormFactors ff;
	ff.FE = 1.;
	ff.FM = 1.;
	return ff;
	}

	FormFactors
	-ElasticFormFactors(double q2, double mi2)
	+ElasticFormFactors( double q2, double mi2 )
	{
	const double GE = pow(1.+q2/0.71, -2.), GM = 2.79*GE;
	FormFactors ff;
	- ff.FE = (4.mi2GEGE+q2GMGM)/(4.mi2+q2);
	+ ff.FE = ( 4.mi2GEGE+q2GMGM ) / ( 4.mi2 + q2 );
	ff.FM = GM*GM;
	return ff;
	}

	FormFactors
	-SuriYennieFormFactors(double q2, double mi2, double mf2)
	+SuriYennieFormFactors( double q2, double mi2, double mf2 )
	{
	// values extracted from experimental fits
	const double cc1 = 0.86926, // 0.6303
	cc2 = 2.23422, // 2.2049
	dd1 = 0.12549, // 0.0468
	cp = 0.96, // 1.23
	bp = 0.63, // 0.61
	rho = 0.585; // 1.05
	const double x = q2/(q2+mf2),
	dm2 = mf2-mi2,
	en = dm2+q2,
	tau = -q2/4./mi2,
	rhot = rho+q2;
	+ const double rho_norm = rho/rhot;
	+
	FormFactors ff;
	- ff.FM = -(-cc1pow(rho/rhot, 2)dm2-cc2mi2pow(1.-x, 4)/(x(xcp-2*bp)+1.))/q2;
	- ff.FE = (-tauff.FM+dd1dm2q2(rho/rhot)pow(dm2/en, 2)/(rhotmi2))/(1.+enen/(4.mi2*q2));
	+ ff.FM = ( -1./q2 ) * ( -cc1rho_normrho_normdm2 - cc2mi2pow( 1.-x, 4 )/( x( xcp-2bp )+1. ) );
	+ ff.FE = ( -tauff.FM + dd1dm2q2rho_normpow( dm2/en, 2 )/( rhotmi2 ) )/( 1. + enen/( 4.mi2*q2 ) );
	return ff;
	}

	FormFactors
	-FioreBrasseFormFactors(double q2, double mi2, double mf2)
	+FioreBrasseFormFactors( double q2, double mi2, double mf2 )
	{
	- const double k = 2.*sqrt(mi2);
	- double dummy, psfw1, psfw2; PSF(-q2, mf2, &dummy, &psfw1, &psfw2);
	+ const double k = 2.*sqrt( mi2 );
	+ // start by computing the proton structure function for this Q**2/mX couple
	+ double dummy, psfw1, psfw2; PSF( -q2, mf2, &dummy, &psfw1, &psfw2 );
	+
	FormFactors ff;
	- ff.FM = psfw1*k/q2;
	- ff.FE = psfw2/k;
	+ ff.FM =-psfw1*k / q2;
	+ ff.FE = psfw2 / k;
	return ff;
	}
	+
	+FormFactors
	+SzczurekUleschenkoFormFactors( double q2, double mi2, double mf2 )
	+{
	+ const double k = 2.*sqrt( mi2 ),
	+ q2_0 = 0.8;
	+
	+ float x = q2 / ( mf2+q2+mi2 ),
	+ amu2 = q2+q2_0; // shift the overall scale
	+ float xuv, xdv, xus, xds, xss, xg;
	+
	+ grv95lo_( x, amu2, xuv, xdv, xus, xds, xss, xg );
	+
	+ const double F2_aux = 4./9.(xuv+2.xus)
	+ + 1./9.(xdv+2.xds)
	+ + 1./9.2.xss;
	+
	+ // F2 corrected for low Q^2 behaviour
	+ const double F2_corr = q2/amu2*F2_aux,
	+ F1 = F2_corr/(2.*x); // Callan-Gross relation
	+
	+ const double w2 = kx/q2F2_corr,
	+ w1 = 2.*F1/k;
	+
	+ FormFactors ff;
	+ ff.FM =-w1*k / q2;
	+ ff.FE = w2 / k;
	+ return ff;
	+}
	+
	+std::ostream&
	+operator<<( std::ostream& os, const FormFactors& ff )
	+{
	+ os << Form( "Form factors: electric: Fe = %.3e ; magnetic: Fm = %.3e", ff.FE, ff.FM ).c_str();
	+ return os;
	+}
	diff --git a/physics/FormFactors.h b/physics/FormFactors.h
	index 0f4752f..002c682 100644
	--- a/physics/FormFactors.h
	+++ b/physics/FormFactors.h
	@@ -1,33 +1,48 @@
	#ifndef FormFactors_h
	#define FormFactors_h

	+#include "core/utils.h"
	#include <math.h>

	#include "physics/Constants.h"
	+#include "physics/Particle.h"

	/**
	* Compute the proton structure function (F.W Brasse et al., DESY 76/11 (1976),
	* http://dx.doi.org/10.1016/0550-3213(76)90231-5)
	- * @cite Brasse1976413
	+ * \param[in] q2 Squared 4-momentum transfer
	+ * \param[in] mx2 Squared mass of the proton remnant
	+ * \param[out] sigma_t ...
	+ * \param[out] w1 First proton structure function: \f$\mathcal W_1\f$
	+ * \param[out] w2 Second proton structure function: \f$\mathcal W_2\f$
	+ * \cite Brasse1976413
	*/
	-bool PSF(double,double,double,double,double*);
	+bool PSF( double q2, double mx2, double* sigma_t, double* w1, double* w2 );
	+extern "C"
	+{
	+ extern void grv95lo_( float&, float&, float&, float&, float&, float&, float&, float& ); // xpart,q2part,uv,dv,us,ds,ss,wg
	+}

	/// Form factors collection (electric and magnetic parts)
	struct FormFactors {
	/// Electric form factor
	double FE;
	/// Magnetic form factor
	double FM;
	+ /// Dumping operator for standard output streams
	+ friend std::ostream& operator<<( std::ostream&, const FormFactors& );
	};
	+
	/// Trivial, spin-0 form factors (e.g. pion)
	FormFactors TrivialFormFactors();
	-
	-FormFactors ElasticFormFactors(double q2, double mi2);
	-
	-FormFactors SuriYennieFormFactors(double q2, double mi2, double mf2);
	-
	-/// Brasse et al. structure functions
	+/// Elastic form factors
	+FormFactors ElasticFormFactors( double q2, double mi2 );
	+/// Suri-Yennie inelastic form factors
	+FormFactors SuriYennieFormFactors( double q2, double mi2, double mf2 );
	+/// Brasse et al. inelastic form factors
	/// \cite Brasse1976413
	-FormFactors FioreBrasseFormFactors(double q2, double mi2, double mf2);
	+FormFactors FioreBrasseFormFactors( double q2, double mi2, double mf2 );
	+/// Szczurek-Uleschenko inelastic form factors
	+FormFactors SzczurekUleschenkoFormFactors( double q2, double mi2, double mf2 );

	#endif
	diff --git a/physics/Kinematics.h b/physics/Kinematics.h
	index 5aca2ac..431a552 100644
	--- a/physics/Kinematics.h
	+++ b/physics/Kinematics.h
	@@ -1,93 +1,94 @@
	#ifndef Kinematics_h
	#define Kinematics_h

	#include <iostream>
	#include <iomanip>
	#include <algorithm>
	#include <string>

	#include "utils.h"

	/// List of kinematic cuts to apply on the central and outgoing phase space.
	class Kinematics
	{
	public:
	Kinematics();
	~Kinematics();

	/**
	- * @brief Set of cuts to apply on the central system
	+ * \brief Set of cuts to apply on the central system
	* - 0 - No cuts at all (for the total cross section)
	* - 1 - Vermaserens' hypothetical detector cuts : for full central particles system,
	* + \f$\frac{\|p_z\|}{\|\mathbf p\|}\leq\f$ 0.75 and \f$p_T\geq 1~\text{GeV}/c\f$,
	* or
	* + 0.75 \f$<\frac{\|p_z\|}{\|\mathbf p\|}\leq\f$ 0.95 and \f$p_z> 1~\text{GeV}/c\f$,
	* - 2 - Cuts on both the outgoing central particles, according to the provided cuts parameters
	* - 3 - Cuts on at least one outgoing central particle, according to the provided cut parameters
	*/
	enum Cuts { NoCuts = 0, VermaserenCuts = 1, BothParticles = 2, OneParticle = 3 };
	+ /// Human-readable format of a cuts mode
	+ friend std::ostream& operator<<( std::ostream&, const Kinematics::Cuts& );
	/// Type of outgoing process kinematics to be considered (elastic/dissociative final states)
	enum ProcessMode {
	ElectronProton = 0,
	ElasticElastic = 1,
	ElasticInelastic = 2,
	InelasticElastic = 3,
	InelasticInelastic = 4
	};
	/// Human-readable format of a process mode (elastic/dissociative parts)
	friend std::ostream& operator<<( std::ostream&, const Kinematics::ProcessMode& );
	- friend std::ostream& operator<<( std::ostream&, const Kinematics::Cuts& );

	/// Dump all the parameters used in this process cross-section computation
	/// or events generation
	void Dump();
	/**
	* Type of kinematics to consider for the process. Can either be :
	* * 0 for the electron-proton elastic case
	* * 1 for the proton-proton elastic case
	* * 2 for the proton-proton single-dissociative (or inelastic-elastic) case
	* * 3 for the proton-proton single-dissociative (or elastic-inelastic) case
	* * 4 for the proton-proton double-dissociative case
	- * @brief Type of kinematics to consider for the phase space
	+ * \brief Type of kinematics to consider for the phase space
	*/
	ProcessMode kinematics;
	/// Sets of cuts to apply on the final phase space
	Cuts mode;
	/// Minimal transverse momentum of the single outgoing leptons
	double ptmin;
	/// Maximal transverse momentum of the single outgoing leptons
	double ptmax;
	/// Minimal energy of the central two-photons system
	double emin;
	/// Maximal energy of the central two-photons system
	double emax;
	/// Minimal rapidity (\f$\eta\f$) of the outgoing lepton
	double etamin;
	/// Maximal rapidity (\f$\eta\f$) of the outgoing lepton
	double etamax;
	/// Minimal mass (in GeV/c\f${}^\mathrm{2}\f$) of the outgoing proton remnant(s)
	double mxmin;
	/// Maximal mass (in GeV/c\f${}^\mathrm{2}\f$) of the outgoing proton remnant(s)
	double mxmax;
	/// Minimal value of \f$Q^2\f$
	double q2min;
	/// Maximal value of \f$Q^2\f$
	double q2max;
	/// Minimal \f$s\f$ on which the cross section is integrated
	double wmin;
	/// Maximal \f$s\f$ on which the cross section is integrated. If negative,
	/// the maximal energy available to the system (hence, \f$s=(\sqrt{s})^{2}\f$)
	/// is provided.
	double wmax;
	/// Minimal difference in outgoing particles' transverse momentum
	double ptdiffmin;
	/// Maximal difference in outgoing particles' transverse momentum
	double ptdiffmax;
	/// Minimal transverse component of the energy transfer
	double qtmin;
	/// Maximal transverse component of the energy transfer
	double qtmax;
	};

	#endif

	diff --git a/physics/Particle.h b/physics/Particle.h
	index b02f562..ce362ed 100644
	--- a/physics/Particle.h
	+++ b/physics/Particle.h
	@@ -1,515 +1,521 @@
	#ifndef Particle_h
	#define Particle_h

	#include <iostream>
	#include <sstream>
	#include <cmath>
	#include <string>
	#include <set>
	#include <map>
	#include <vector>
	#include <algorithm>

	#include "core/utils.h"

	+/// A set of integer-type particle identifiers
	typedef std::set<int> ParticlesIds;

	/// Kinematic information for one particle
	class Particle {
	public:
	/** Unique identifier for a particle type. From @cite Beringer:1900zz :
	* _The Monte Carlo particle numbering scheme [...] is intended to facilitate interfacing between event generators, detector simulators, and analysis packages used in particle physics._
	* \brief PDG ids of all known particles
	*/
	enum ParticleCode {
	invalidParticle = 0,
	dQuark = 1,
	uQuark = 2,
	Electron = 11,
	ElectronNeutrino = 12,
	Muon = 13,
	MuonNeutrino = 14,
	Tau = 15,
	TauNeutrino = 16,
	Gluon = 21,
	Photon = 22,
	Z = 23,
	WPlus = 24,
	PiPlus = 211,
	PiZero = 111,
	Rho770_0 = 113,
	Rho1450_0 = 100113,
	Rho1700_0 = 30113,
	Omega782 = 223,
	h1380_1 = 10333,
	JPsi= 443,
	Phi1680 = 100333,
	Upsilon1S = 553,
	Upsilon2S = 100553,
	Upsilon3S = 200553,
	ud0Diquark = 2101,
	ud1Diquark = 2103,
	uu1Diquark = 2203,
	Proton = 2212,
	Neutron = 2112,
	Pomeron = 990,
	Reggeon = 110
	};
	/// Internal status code for a particle
	enum Status {
	PrimordialIncoming = -9,
	Incoming = -1,
	Undecayed = -3,
	sPropagator = -2,
	Undefined = 0,
	FinalState = 1,
	Resonance = 2,
	DebugResonance = 3,
	PythiaHIncoming = 21,
	HerwigFragment = 193 //FIXME
	};
	/// Role of the particle in the process
	enum Role {
	UnknownRole = -1,
	IncomingBeam1 = 1,
	IncomingBeam2 = 2,
	Parton1 = 41,
	Parton2 = 42,
	Parton3 = 43,
	CentralSystem = 4,
	OutgoingBeam1 = 3,
	OutgoingBeam2 = 5,
	CentralParticle1 = 6,
	CentralParticle2 = 7
	};
	/**
	* Container for a particle's 4-momentum, along with useful methods to ease the development of any matrix element level generator
	* \brief 4-momentum for a particle
	* \date Dec 2015
	* \author Laurent Forthomme <laurent.forthomme@cern.ch>
	*/
	class Momentum {
	public:
	/// Build a 4-momentum at rest with an invalid energy (no mass information known)
	inline Momentum() : fPx( 0. ), fPy( 0. ), fPz( 0. ), fP( 0. ), fE( -1. ) {;}
	/// Build a 4-momentum using its 3-momentum coordinates and its energy
	inline Momentum( double x_, double y_, double z_, double t_=-1. ) :
	fPx( x_ ), fPy( y_ ), fPz( z_ ), fE( t_ ) { ComputeP(); }
	inline ~Momentum() {;}

	inline void SetMomentum( const Momentum& p ) {
	fPx = p.fPx; fPy = p.fPy; fPz = p.fPz, fE = p.fE; fP = p.fP;
	}

	// --- static definitions

	/// Build a 3-momentum from its three pseudo-cylindric coordinates
	static inline Momentum FromPtEtaPhi( double pt, double eta, double phi, double e=-1. ) {
	const double px = pt*cos( phi ),
	py = pt*sin( phi ),
	pz = pt*sinh( eta );
	return Momentum( px, py, pz, e );
	}
	/// Build a 4-momentum from its scalar momentum, and its polar and azimuthal angles
	static inline Momentum FromPThetaPhi( double p, double theta, double phi, double e=-1. ) {
	const double px = psin( theta )cos( phi ),
	py = psin( theta )sin( phi ),
	pz = p*cos( theta );
	return Momentum( px, py, pz, e );
	}
	/// Build a 4-momentum from its four momentum and energy coordinates
	static inline Momentum FromPxPyPzE( double px, double py, double pz, double e ) {
	return Momentum( px, py, pz, e );
	}

	// --- vector and scalar operators

	void operator=( const Momentum& );
	/// Scalar product of the 3-momentum with another 3-momentum
	double ThreeProduct( const Momentum& ) const;
	/// Scalar product of the 4-momentum with another 4-momentum
	double FourProduct( const Momentum& ) const;
	/// Add a 4-momentum through a 4-vector sum
	Momentum& operator+=( const Momentum& );
	/// Subtract a 4-momentum through a 4-vector sum
	Momentum& operator-=( const Momentum& );
	/// Scalar product of the 3-momentum with another 3-momentum
	double operator*=( const Momentum& );
	/// Multiply all 4-momentum coordinates by a scalar
	Momentum& operator*=( double c );
	/// Human-readable format for a particle's momentum
	friend std::ostream& operator<<( std::ostream& os, const Particle::Momentum& mom );

	void BetaGammaBoost( double gamma, double betagamma );
	/// Forward Lorentz boost
	void LorentzBoost( const Particle::Momentum& p );

	// --- setters and getters

	/// Set all the components of the 4-momentum (in GeV)
	inline bool SetP( double px_,double py_,double pz_, double e_ ) {
	SetP( px_, py_, pz_ ); SetE( e_ );
	return true;
	}
	/// Set all the components of the 3-momentum (in GeV)
	inline void SetP( double px_,double py_,double pz_ ) {
	fPx = px_;
	fPy = py_;
	fPz = pz_;
	ComputeP();
	}
	/// Set an individual component of the 4-momentum (in GeV)
	inline void SetP(unsigned int i, double p_) {
	switch ( i ) {
	case 0: fPx = p_; break;
	case 1: fPy = p_; break;
	case 2: fPz = p_; break;
	case 3: fE = p_; break;
	default: return;
	}
	ComputeP();
	}
	/// Set the energy (in GeV)
	inline void SetE( double e_ ) { fE = e_; }
	/// Compute the energy from the mass
	inline void SetM( double m_ ) { fE = sqrt( P2()+m_*m_ ); }
	/// Compute the energy from the mass
	inline void SetM2(double m2) { fE = sqrt( P2()+m2 ); }
	/// Get one component of the 4-momentum (in GeV)
	inline double P( unsigned int i ) const {
	switch ( i ) {
	case 0: return fPx;
	case 1: return fPy;
	case 2: return fPz;
	case 3: return fE;
	default: return -1.;
	}
	}
	/// Get one component of the 4-momentum (in GeV)
	inline double& operator[]( const unsigned int i ) {
	switch ( i ) {
	case 0: return fPx; break;
	case 1: return fPy; break;
	case 2: return fPz; break;
	case 3: return fE; break;
	}
	}
	/// Get the momentum along the \f$x\f$-axis (in GeV)
	inline double Px() const { return fPx; }
	/// Get the momentum along the \f$y\f$-axis (in GeV)
	inline double Py() const { return fPy; }
	/// Get the longitudinal momentum (in GeV)
	inline double Pz() const { return fPz; }
	/// Get the transverse momentum (in GeV)
	inline double Pt() const { return sqrt( Px()Px()+Py()Py() ); }
	/// Get the 3-momentum norm (in GeV)
	inline double P() const { return fP; }
	/// Get the squared 3-momentum norm (in \f$\text{GeV}^\text{2}\f$)
	inline double P2() const { return fP*fP; }
	/// Get the energy (in GeV)
	inline double E() const { return fE; }
	/// Get the squared energy (in GeV^2)
	inline double E2() const { return fE*fE; }
	/// Get the particle's squared mass (in GeV^2) as computed from its energy and momentum
	inline double M2() const { return E2()-P2(); }
	/// Get the particle's mass (in GeV) as computed from its energy and momentum
	inline double M() const { return sqrt( M2() ); }
	/// Get the polar angle (angle with respect to the longitudinal direction)
	inline double Theta() const { return atan2( Pt(), Pz() ); }
	/// Get the azimutal angle (angle in the transverse plane)
	inline double Phi() const { return atan2( Py(), Px() ); }
	/// Get the pseudo-rapidity
	inline double Eta() const {
	const int sign = ( Pz()/fabs( Pz() ) );
	return ( Pt()!=0. )
	? log( ( P()+fabs( Pz() ) )/Pt() )*sign
	: 9999.*sign;
	};
	/// Get the rapidity
	inline double Rapidity() const {
	const int sign = ( Pz()/fabs( Pz() ) );
	return ( E()>=0. )
	? log( ( E()+Pz() )/( E()-Pz() ) )/2.
	: 999.*sign;
	}
	/// Rotate the transverse components by an angle phi (and reflect the y coordinate)
	void RotatePhi( double phi, double sign );
	/// Rotate the particle's momentum by a polar/azimuthal angle
	void RotateThetaPhi( double theta_, double phi_ );
	private:
	/// Compute the 3-momentum's norm
	inline void ComputeP() {
	fP = 0.;
	for ( unsigned int i=0; i<3; i++ ) fP += P(i)*P(i);
	fP = sqrt( fP );
	}
	/// Momentum along the \f$x\f$-axis
	double fPx;
	/// Momentum along the \f$y\f$-axis
	double fPy;
	/// Momentum along the \f$z\f$-axis
	double fPz;
	/// 3-momentum's norm (in GeV/c)
	double fP;
	/// Energy (in GeV)
	double fE;
	};
	/// Human-readable format for a particle's PDG code
	friend std::ostream& operator<<( std::ostream& os, const Particle::ParticleCode& pc );
	/// Compute the 4-vector sum of two 4-momenta
	friend Particle::Momentum operator+( const Particle::Momentum& mom1, const Particle::Momentum& mom2 );
	/// Compute the 4-vector difference of two 4-momenta
	friend Particle::Momentum operator-( const Particle::Momentum& mom1, const Particle::Momentum& mom2 );
	/// Scalar product of two 3-momenta
	friend double operator*( const Particle::Momentum& mom1, const Particle::Momentum& mom2 );
	/// Multiply all components of a 4-momentum by a scalar
	friend Particle::Momentum operator*( const Particle::Momentum& mom, double c );
	/// Multiply all components of a 4-momentum by a scalar
	friend Particle::Momentum operator*( double c, const Particle::Momentum& mom );
	/**
	* Gets the mass in GeV/c**2 of a particle given its PDG identifier
	* @brief Gets the mass of a particle
	* @param pdgId_ ParticleCode (PDG ID)
	* @return Mass of the particle in \f$\text{GeV}/c^2\f$
	*/
	static double GetMassFromPDGId( const Particle::ParticleCode& pdgId_ );
	/**
	* Gets the total decay width for one particle to be decayed
	* @param[in] pdgId_ ParticleCode (PDG ID)
	* @return Decay width in GeV
	*/
	static double GetWidthFromPDGId( const Particle::ParticleCode& pdgId_ );

	Particle();
	/// Build using the role of the particle in the process and its PDG id
	/// \param[in] pdgId_ ParticleCode (PDG ID)
	/// \param[in] role_ Role of the particle in the process
	Particle( Role role_, ParticleCode pdgId_=Particle::invalidParticle );
	inline ~Particle() {;}
	/// Assignment operator
	Particle& operator=( const Particle& );
	/// Comparison operator (from unique identifier)
	inline bool operator<( const Particle& rhs ) { return id<rhs.id; }
	/// Comparison operator (from their reference's unique identifier)
	inline bool operator<( const Particle *rhs ) { return id<rhs->id; }
	void LorentzBoost( double m_, const Momentum& mom_ );
	/// Lorentz boost (shamelessly stolen from ROOT)
	double* LorentzBoost( const Momentum& mom_ );

	// --- general particle properties

	/// Unique identifier (in a Event object context)
	int id;
	/// Electric charge (given as a float number, for the quarks and bound states)
	float charge;
	/// Human-readable name
	std::string name;
	/// Role in the considered process
	Role role;
	/**
	* Codes 1-10 correspond to currently existing partons/particles, and larger codes contain partons/particles which no longer exist, or other kinds of event information
	* @brief Particle status
	*/
	Status status;

	/// Set the PDG identifier (along with the particle's electric charge)
	/// \param[in] pdg ParticleCode (PDG ID)
	/// \param[in] ch Electric charge (in units of \f$e\f$)
	inline void SetPDGId( const ParticleCode& pdg, float ch=-999. ) {
	fPDGid = pdg;
	if (ch==-999.) charge = 0.;
	else charge = ch;
	}
	/// Retrieve the objectified PDG identifier
	inline ParticleCode GetPDGId() const { return fPDGid; }
	/// Retrieve the integer value of the PDG identifier
	inline int GetIntPDGId() const {
	const int pdg = static_cast<int>( fPDGid );
	if ( pdg>10 and pdg<16 and pdg%2!=0 ) return static_cast<int>( -charge )*pdg;
	else return pdg;
	}
	/// Particle's helicity
	/// \note FIXME Float??
	float helicity;
	/**
	* Gets the particle's mass in \f$\text{GeV}/c^{2}\f$.
	* @brief Gets the particle's mass
	* @return The particle's mass
	*/
	inline double M() const { return fMass; };
	/**
	* Set the mass of the particle in \f$\text{GeV}/c^{2}\f$ according to a value given as an argument. This method ensures that the kinematics is properly set (the mass is set according to the energy and the momentum in priority)
	* @param m_ The mass in \f$\text{GeV}/c^{2}\f$ to set
	* @brief Set the particle's mass in \f$\text{GeV}/c^{2}\f$
	* @return A boolean stating whether or not the mass was correctly set
	*/
	bool SetM( double m_=-1. );
	/// Get the particle's squared mass (in \f$\text{GeV}^\text{2}\f$)
	inline double M2() const { return fMass*fMass; };
	/// Retrieve the momentum object associated with this particle
	inline Momentum GetMomentum() const { return fMomentum; }
	/// Associate a momentum object to this particle
	inline bool SetMomentum( const Momentum& mom, bool offshell=false ) {
	fMomentum = mom;
	if ( offshell ) {
	fMass = fMomentum.M();
	return true;
	}

	if ( fMass<0. ) SetM();
	const double e = sqrt( fMomentum.P2()+M2() );
	if ( mom.E()<0. ) {
	fMomentum.SetE(e);
	return true;
	}

	if ( fabs(e-fMomentum.E() )<1.e-6 or fabs(e-mom.E())<1.e-6 ) { // less than 1 eV difference
	return true;
	}
	if ( role!=Parton1 and role!=Parton2 ) {
	InError( Form( "Energy difference for particle %d (computed-set): %.5f", (int)role, e-fMomentum.E() ) );
	}
	fMomentum.SetE( e );//FIXME need to ensure nothing relies on this
	return false;
	}
	/**
	* @brief Set the 3-momentum associated to the particle
	* @param[in] px_ Momentum along the \f$x\f$-axis, in \f$\text{GeV}/c\f$
	* @param[in] py_ Momentum along the \f$y\f$-axis, in \f$\text{GeV}/c\f$
	* @param[in] pz_ Momentum along the \f$z\f$-axis, in \f$\text{GeV}/c\f$
	* @return A boolean stating the validity of this particle (according to its 4-momentum norm)
	*/
	inline bool SetMomentum( double px_,double py_,double pz_ ) {
	fMomentum.SetP( px_, py_, pz_ ); SetE();
	return true;
	};
	/**
	* @brief Set the 4-momentum associated to the particle
	* @param[in] px_ Momentum along the \f$x\f$-axis, in \f$\text{GeV}/c\f$
	* @param[in] py_ Momentum along the \f$y\f$-axis, in \f$\text{GeV}/c\f$
	* @param[in] pz_ Momentum along the \f$z\f$-axis, in \f$\text{GeV}/c\f$
	* @param[in] e_ Energy, in GeV
	* @return A boolean stating the validity of the particle's kinematics
	*/
	inline bool SetMomentum( double px_,double py_,double pz_,double e_ ) {
	SetMomentum( px_, py_, pz_ );
	if ( fabs( e_-fMomentum.E() )>1.e-6 ) { // more than 1 eV difference
	InError( Form( "Energy difference: %.5f", e_-fMomentum.E() ) );
	return false;
	}
	return true;
	};
	/**
	* @brief Set the 4-momentum associated to the particle
	* @param[in] p_ 4-momentum
	* @return A boolean stating the validity of the particle's kinematics
	*/
	inline bool SetMomentum( double p_[4] ) { return SetMomentum( p_[0], p_[1], p_[2], p_[3] ); }
	/**
	* @brief Set the particle's energy
	* @param[in] e_ Energy, in GeV
	*/
	inline void SetE(double e_=-1.) {
	if ( e_<0. and fMass>=0. ) e_ = sqrt( M2()+fMomentum.P2() );
	fMomentum.SetE(e_);
	}
	/// Get the particle's energy (in GeV)
	inline double E() const {
	return ( fMomentum.E()<0. ) ? std::sqrt( M2()+fMomentum.P2() ) : fMomentum.E();
	};
	/// Get the particle's squared energy (in \f$\text{GeV}^\text{2}\f$)
	inline double E2() const { return E()*E(); };
	/// Is this particle a valid particle which can be used for kinematic computations ?
	bool Valid();

	// --- particle relations

	/// Is this particle a primary particle ?
	inline bool Primary() const { return fIsPrimary; }
	/**
	* @brief Set the mother particle
	* @param[in] part_ A Particle object containing all the information on the mother particle
	*/
	void SetMother( Particle* part_ );
	/**
	* @brief Gets the unique identifier to the mother particle from which this particle arises
	* @return An integer representing the unique identifier to the mother of this particle in the event
	*/
	inline ParticlesIds GetMothersIds() const { return fMothers; }
	/**
	* @brief Add a decay product
	* @param[in] part_ The Particle object in which this particle will desintegrate or convert
	* @return A boolean stating if the particle has been added to the daughters list or if it was already present before
	*/
	bool AddDaughter( Particle* part_ );
	/// Gets the number of daughter particles
	inline unsigned int NumDaughters() const { return fDaughters.size(); };
	/**
	* @brief Get an identifiers list all daughter particles
	* @return An integer vector containing all the daughters' unique identifier in the event
	*/
	ParticlesIds GetDaughters() const { return fDaughters; }

	// --- global particle information extraction

	/**
	* Returns a string containing all the particle's kinematics as expressed in the Les Houches format
	* @param[in] revert_ Is the event symmetric ? If set to true, the third component of the momentum is reverted.
	* @return The LHE line associated to the particle, and containing the particle's history (mother/daughters), its kinematics, and its status
	*/
	std::string GetLHEline( bool revert_=false );
	/// Dump all the information on this particle into the standard output stream
	void Dump() const;
	void PDF2PDG();

	// --- other methods

	/**
	* Hadronise the particle with a generic hadroniser, and builds the shower (list of Particle objects) embedded in this object
	* @param[in] algo_ Algorithm in use to hadronise the particle
	* @brief Hadronises the particle using Pythia
	* @return A boolean stating whether or not the particle has been hadronised
	*/
	bool Hadronise( std::string algo_ );
	private:
	/// Momentum properties handler
	Momentum fMomentum;
	/// Mass in \f$\text{GeV}/c^2\f$
	double fMass;
	/// List of mother particles
	ParticlesIds fMothers;
	/// List of daughter particles
	ParticlesIds fDaughters;
	/// PDG id
	ParticleCode fPDGid;
	/// Is the particle a primary particle ?
	bool fIsPrimary;
	double __tmp3[3];
	};

	inline bool compareParticle( const Particle a, const Particle b ) { return a.id<b.id; }
	inline bool compareParticlePtrs( const Particle* a, const Particle* b ) { return a->id<b->id; }

	/// Compute the centre of mass energy of two particles (incoming or outgoing states)
	inline static double CMEnergy( const Particle& p1, const Particle& p2 ) {
	if (p1.M()*p2.M()<0.) return 0.;
	if (p1.E()*p2.E()<0.) return 0.;
	return sqrt(p1.M2()+p2.M2()+2.p1.E()p2.E()-2.(p1.GetMomentum()p2.GetMomentum()));
	}

	/// Compute the centre of mass energy of two particles (incoming or outgoing states)
	inline static double CMEnergy( const Particle::Momentum& m1, const Particle::Momentum& m2 ) {
	if (m1.M()*m2.M()<0.) return 0.;
	if (m1.E()*m2.E()<0.) return 0.;
	return sqrt(m1.M2()+m2.M2()+2.m1.E()m2.E()-2.(m1m2));
	}

	// --- particle containers

	+/// List of Particle objects
	typedef std::vector<Particle> Particles;
	+/// List of references to Particle objects
	typedef std::vector<Particle*> ParticlesRef;
	+/// List of references to constant Particle objects
	typedef std::vector<const Particle*> ConstParticlesRef;
	+/// List of particles' roles
	typedef std::vector<Particle::Role> ParticleRoles;
	+/// Map between a particle's role and its associated Particle object
	typedef std::multimap<Particle::Role,Particle> ParticlesMap;

	#endif
	diff --git a/physics/PhotonFluxes.cpp b/physics/PhotonFluxes.cpp
	index d6a7c41..649cafc 100644
	--- a/physics/PhotonFluxes.cpp
	+++ b/physics/PhotonFluxes.cpp
	@@ -1,85 +1,81 @@
	#include "PhotonFluxes.h"

	double
	PhotonFluxes::ProtonElastic( double x_, double kt2_ )
	{
	double f_ela;

	const double mp = Particle::GetMassFromPDGId(Particle::Proton),
	mp2 = mp*mp;

	const double Q2_ela = ( kt2_+x_x_mp2 )/( 1.-x_ );
	const FormFactors ela = ElasticFormFactors( Q2_ela, mp2 );

	- /*const double G_dip = 1./pow(1.+Q2_ela/0.71, 2);
	- const double G_E = G_dip;
	- const double G_M = 2.79G_dip;/
	-
	const double ela1 = pow( kt2_/( kt2_+x_x_mp2 ), 2 );
	const double ela2 = ela.FE;
	//const double ela3 = 1.-(Q2_ela-kt2_)/Q2_ela;
	//const double ela3 = 1.-pow(x_, 2)*mp2/Q2_ela/(1.-x_);
	//f_ela = alpha_em/Constants::Pi(1.-x_+pow(x_, 2)/4.)ela1ela2ela3/kt2_;
	f_ela = Constants::AlphaEM/Constants::Piela1ela2/Q2_ela;
	- //f_ela = Constants::AlphaEM/Constants::Pi((1.-x_)ela1ela2ela3+pow(x_, 2)/2.*pow(G_M, 2))/kt2_;
	+ //f_ela = Constants::AlphaEM/Constants::Pi( ( 1.-x_ )ela1ela2ela3 + x_x_/2.G_M*G_M )/kt2_;

	return f_ela;
	}

	#ifdef GRVPDF

	double
	PhotonFluxes::ProtonInelastic( double x_, double kt2_, double mx_ )
	{
	double f_ine;

	const double mx2 = mx_*mx_,
	mp = Particle::GetMassFromPDGId( Particle::Proton ),
	mp2 = mp*mp;
	//const double mpi = pow(Particle::GetMassFromPDGId(Particle::PiZero), 2);

	const double Q02 = 0.8; // introduced to shift the Q2 scale
	double term1, term2;
	double f_aux;

	// F2 structure function
	const double Q2min = 1. / ( 1.-x_ )( x_( mx2-mp2 ) + x_x_mp2 ),
	Q2 = kt2_ / ( 1.-x_ ) + Q2min;
	float x_Bjorken = Q2 / ( Q2+mx2-mp2 );

	float mu2 = Q2+Q02; // scale is shifted

	float xuv, xdv, xus, xds, xss, xg;
	grv95lo_( x_Bjorken, mu2, xuv, xdv, xus, xds, xss, xg );
	DebuggingInsideLoop( Form( "Form factor content at xB = %e (scale = %f GeV^2):\n\t"
	" valence quarks: u / d = %e / %e\n\t"
	" sea quarks: u / d / s = %e / %e / %e\n\t"
	" gluons: = %e",
	x_Bjorken, mu2, xuv, xdv, xus, xds, xss, xg ) );

	const double F2_aux = 4./9.( xuv + 2.xus )
	+ 1./9.( xdv + 2.xds )
	+ 1./9.2.xss;

	/F2_aux = 4./9.(xuv + 2.*xus)
	+ 1./9.(0. + 2.xds)
	+ 1./9.2.xss;*/

	// F2 corrected for low Q^2 behaviour
	const double F2_corr = Q2 / ( Q2+Q02 ) * F2_aux;

	///////term1 = pow(1.- x_/2.*(mx2-mp2+Q2)/Q2, 2);
	//term1 = (1.-x_*(mx2-mp2+Q2)/Q2);
	term1 = ( 1. - ( Q2-kt2_ ) / Q2 );
	//term1 = (1.-Q2min/Q2);
	//term1 = 1.;
	term2 = pow( kt2_ / ( kt2_+x_(mx2-mp2)+x_x_*mp2 ), 2 );

	f_aux = F2_corr/( mx2+Q2-mp2 )term1term2;

	f_ine = Constants::AlphaEM/Constants::Pi( 1.-x_ )f_aux/kt2_;

	return f_ine;
	}

	#endif
	diff --git a/physics/PhotonFluxes.h b/physics/PhotonFluxes.h
	index d7bdc03..62f0b27 100644
	--- a/physics/PhotonFluxes.h
	+++ b/physics/PhotonFluxes.h
	@@ -1,29 +1,24 @@
	#ifndef Physics_PhotonFluxes_h
	#define Physics_PhotonFluxes_h

	#include "Particle.h"
	#include "FormFactors.h"
	#include "core/Exception.h"

	-extern "C"
	-{
	- extern void grv95lo_( float&, float&, float&, float&, float&, float&, float&, float& ); // xpart,q2part,uv,dv,us,ds,ss,wg
	-}
	-
	namespace PhotonFluxes
	{
	/// Get the elastic flux to be expected at a given x_bjorken / kT
	double ProtonElastic(double x_, double kt2_);

	#ifdef GRVPDF
	/// Get the inelastic flux to be expected at a given x_bjorken / kT
	double ProtonInelastic(double x_, double kt2_, double mx_);
	#else
	inline double ProtonInelastic(double x_, double kt2_, double mx_) {
	InError( "Inelastic flux cannot be computed as GRV PDF set is not linked to this instance!" );
	exit(0);
	}
	#endif
	}

	#endif
	diff --git a/processes/GamGamLL.cpp b/processes/GamGamLL.cpp
	index 7545c47..3f002cc 100644
	--- a/processes/GamGamLL.cpp
	+++ b/processes/GamGamLL.cpp
	@@ -1,909 +1,911 @@
	#include "GamGamLL.h"

	GamGamLL::GamGamLL(int nOpt_) : GenericProcess("pp -> p() (gamma gamma -> l+ l-) p()"),
	_nOpt(nOpt_),
	_ep1( -1. ), _w1( -1. ), _ep2( -1. ), _w2( -1. ),
	fMX2( -1. ), _w4( -1. ), fMY2( -1. ), fMl12( -1. ), fMl22( -1. ),
	_p12( 0. ), _p13( 0. ), _p14( 0. ), _p15( 0. ),
	_p23( 0. ), _p24( 0. ), _p25( 0. ), _p34( 0. ), _p35( 0. ), _p45( 0. ),
	_p1k2( 0. ), _p2k1( 0. ),
	_cotth1( -99999. ), _cotth2( 99999. )
	{}

	void
	GamGamLL::AddEventContent()
	{
	IncomingState is; OutgoingState os;
	is.insert( ParticleWithRole(Particle::IncomingBeam1, Particle::Proton ) );
	is.insert( ParticleWithRole(Particle::IncomingBeam2, Particle::Proton ) );
	is.insert( ParticleWithRole(Particle::Parton1, Particle::Photon ) );
	is.insert( ParticleWithRole(Particle::Parton2, Particle::Photon ) );
	os.insert( ParticleWithRole(Particle::OutgoingBeam1, Particle::Proton ) );
	os.insert( ParticleWithRole(Particle::OutgoingBeam2, Particle::Proton ) );
	os.insert( ParticleWithRole(Particle::CentralParticle1, Particle::Muon ) );
	os.insert( ParticleWithRole(Particle::CentralParticle2, Particle::Muon ) );
	GenericProcess::SetEventContent( is, os );
	}

	unsigned int
	GamGamLL::GetNdim( const Kinematics::ProcessMode& process_mode_ ) const
	{
	switch ( process_mode_ ) {
	case Kinematics::ElectronProton: { InError( "Not supported yet!" ); }
	case Kinematics::ElasticElastic:
	default: return 7;
	case Kinematics::ElasticInelastic:
	case Kinematics::InelasticElastic: return 8;
	case Kinematics::InelasticInelastic: return 9;
	}
	}

	bool
	GamGamLL::Pickin()
	{
	double sig, sig1, sig2; // sig1 = sigma and sig2 = sigma' in [1]
	double sb, sd, se;
	double splus, s2x;
	double s2min, s2max;
	double ds2;
	double s1p, s1m, s1pp, s1pm, s2p;
	double sl2, sl3, sl4, sl5, sl6, sl7;
	double dt1, dt2;
	double t13, t25;
	double b, c;

	DebuggingInsideLoop(Form("Optimised mode? %i", _nOpt));

	fJacobian = 0.;

	_w4 = std::pow(_mc4, 2);

	sig = _mc4+fMY;
	sig1 = std::pow(sig, 2);
	sig2 = std::pow(sig, 2);

	DebuggingInsideLoop(Form("mc4 = %f\n\t"
	"sig1 = %f\n\t"
	"sig2 = %f", _mc4, sig1, sig2));

	// Mass difference between the first outgoing particle and the first incoming
	// particle
	_w31 = fMX2-_w1;
	// Mass difference between the second outgoing particle and the second
	// incoming particle
	_w52 = fMY2-_w2;
	// Mass difference between the two incoming particles
	_w12 = _w1-_w2;
	// Mass difference between the central two-photons system and the second
	// outgoing particle
	const double d6 = _w4-fMY2;

	DebuggingInsideLoop(Form("w1 = %f\n\t"
	"w2 = %f\n\t"
	"w3 = %f\n\t"
	"w4 = %f\n\t"
	"w5 = %f",
	_w1, _w2, fMX2, _w4, fMY2));

	//Info(Form("w31 = %f\n\tw52 = %f\n\tw12 = %f", _w31, _w52, _w12));

	const double ss = fS+_w12;

	const double rl1 = std::pow(ss, 2)-4._w1fS; // lambda(s, m12, m22)
	if (rl1<=0.) { InWarning(Form("rl1 = %f <= 0", rl1)); return false; }
	_sl1 = std::sqrt(rl1);

	fS2 = ds2 = 0.;
	if (_nOpt==0) {
	const double smax = fS+fMX2-2.fMXfSqS;
	Map(x(2), sig1, smax, &fS2, &ds2, "s2");
	sig1 = fS2; //FIXME!!!!!!!!!!!!!!!!!!!!
	}

	DebuggingInsideLoop(Form("s2 = %f", fS2));

	//std::cout << "s=" << _s << ", w3=" << fMX2 << ", sig1=" << sig1 << std::endl;
	const double sp = fS+fMX2-sig1;

	_d3 = sig1-_w2;

	const double rl2 = std::pow(sp, 2)-4.fSfMX2; // lambda(s, m3**2, sigma)
	if (rl2<=0.) { InWarning(Form("rl2 = %f <= 0", rl2)); return false; }
	sl2 = std::sqrt(rl2);

	//std::cout << "ss=" << ss << ", sp=" << sp << ", sl1=" << _sl1 << ", sl2=" << sl2 << std::endl;
	fT1max = _w1+fMX2-(sssp+_sl1sl2)/(2.*fS); // definition from eq. (A.4) in [1]
	fT1min = (_w31_d3+(_d3-_w31)(_d3_w1-_w31_w2)/fS)/fT1max; // definition from eq. (A.5) in [1]

	// FIXME dropped in CDF version
	if (fT1max>-fCuts.q2min) { InWarning(Form("t1max = %f > -q2min = %f", fT1max, -fCuts.q2min)); return false; }
	if (fT1min<-fCuts.q2max and fCuts.q2max>=0.) { InWarning(Form("t1min = %f < -q2max = %f", fT1min, -fCuts.q2max)); return false; }
	if (fT1max<-fCuts.q2max and fCuts.q2max>=0.) fT1max = -fCuts.q2max;
	if (fT1min>-fCuts.q2min) fT1min = -fCuts.q2min;
	/////

	// t1, the first photon propagator, is defined here
	Map(x(0), fT1min, fT1max, &fT1, &dt1, "t1");
	// changes wrt mapt1 : dx->-dx
	dt1 = -dt1;

	DebuggingInsideLoop(Form("Definition of t1 = %f according to\n\t"
	"(t1min, t1max) = (%f, %f)", fT1, fT1min, fT1max));

	_dd4 = _w4-fT1;
	const double d8 = fT1-_w2;

	t13 = fT1-_w1-fMX2;

	_sa1 =-std::pow(fT1-_w31, 2)/4.+_w1*fT1;
	if (_sa1>=0.) { InWarning(Form("_sa1 = %f >= 0", _sa1)); return false; }

	sl3 = std::sqrt(-_sa1);

	// one computes splus and (s2x=s2max)
	if (_w1!=0.) {
	sb =(fS(fT1-_w31)+_w12t13)/(2.*_w1)+fMX2;
	sd = _sl1*sl3/_w1;
	se =(fS(fT1(fS+t13-_w2)-_w2_w31)+fMX2(_w12d8+_w2fMX2))/_w1;
	if (fabs((sb-sd)/sd)>=1.) { splus = sb-sd; s2max = se/splus; }
	else { s2max = sb+sd; splus = se/s2max; }
	}
	else { // 3
	s2max = (fS(fT1(fS+d8-fMX2)-_w2fMX2)+_w2fMX2(_w2+fMX2-fT1))/(sst13);
	splus = sig2;
	}
	// 4
	s2x = s2max;

	DebuggingInsideLoop(Form("s2x = s2max = %f", s2x));

	if (_nOpt<0) { // 5
	if (splus>sig2) {
	sig2 = splus;
	DebuggingInsideLoop(Form("sig2 truncated to splus = %f", splus));
	}
	if (_nOpt<-1) { Map(x(2), sig2, s2max, &fS2, &ds2, "s2"); }
	else { Mapla(fT1, _w2, x(2), sig2, s2max, &fS2, &ds2); } // _nOpt==-1
	s2x = fS2;
	}
	else if (_nOpt==0) { s2x = fS2; } // 6

	DebuggingInsideLoop(Form("s2x = %f", s2x));

	// 7
	const double r1 = s2x-d8,
	r2 = s2x-d6;

	const double rl4 = (std::pow(r1, 2)-4._w2s2x)(std::pow(r2, 2)-4.fMY2*s2x);
	if (rl4<=0.) { InWarning(Form("rl4 = %f <= 0", rl4)); return false; }
	sl4 = std::sqrt(rl4);

	// t2max, t2min definitions from eq. (A.12) and (A.13) in [1]
	fT2max = _w2+fMY2-(r1r2+sl4)/(2.s2x);
	fT2min = (_w52_dd4+(_dd4-_w52)(_dd4_w2-_w52fT1)/s2x)/fT2max;

	// t2, the second photon propagator, is defined here
	Map(x(1), fT2min, fT2max, &fT2, &dt2, "t2");
	// changes wrt mapt2 : dx->-dx

	dt2 = -dt2;

	// \f$\delta_6=m_4^2-m_5^2\f$ as defined in Vermaseren's paper
	const double tau = fT1-fT2,
	r3 = _dd4-fT2,
	r4 = _w52-fT2;

	DebuggingInsideLoop(Form("r1 = %f\n\tr2 = %f\n\tr3 = %f\n\tr4 = %f", r1, r2, r3, r4));

	b = r3r4-2.(fT1+_w2)*fT2;
	c = fT2d6d8+(d6-d8)(d6_w2-d8*fMY2);
	t25 = fT2-_w2-fMY2;

	_sa2 = -std::pow(r4, 2)/4.+_w2*fT2;
	if (_sa2>=0.) { InWarning(Form("_sa2 = %f >= 0", _sa2)); return false; }

	sl6 = 2.*std::sqrt(-_sa2);

	_g4 = -std::pow(r3, 2)/4.+fT1*fT2;
	if (_g4>=0.) { InWarning(Form("_g4 = %f >= 0", _g4)); return false; }

	sl7 = std::sqrt(-_g4)*2.;
	sl5 = sl6*sl7;
	if (fabs((sl5-b)/sl5)>=1.) {
	s2p = (sl5-b)/(2.*fT2);
	s2min = c/(fT2*s2p);
	}
	else { // 8
	s2min = (-sl5-b)/(2.*fT2);
	s2p = c/(fT2*s2min);
	}
	// 9
	if (_nOpt>1) Map(x(2), s2min, s2max, &fS2, &ds2, "s2");
	else if (_nOpt==1) Mapla(fT1, _w2, x(2), s2min, s2max, &fS2, &ds2);

	const double ap = -std::pow(fS2+d8, 2)/4.+fS2*fT1;
	//Info(Form("s2 = %f, s2max = %f, splus = %f", fS2, s2max, splus));
	if (_w1!=0.) _dd1 = -_w1(fS2-s2max)(fS2-splus)/4.; // 10
	else _dd1 = sst13(fS2-s2max)/4.;
	// 11
	_dd2 = -fT2(fS2-s2p)(fS2-s2min)/4.;
	DebuggingInsideLoop(Form("t2 =%f\n\ts2 =%f\n\ts2p=%f\n\ts2min=%f\n\tdd2=%f",fT2, fS2, s2p, s2min, _dd2));

	const double yy4 = cos(Constants::Pi*x(3));
	const double dd = _dd1*_dd2;
	_p12 = (fS-_w1-_w2)/2.;
	const double st = fS2-fT1-_w2;
	const double delb = (2._w2r3+r4st)(4._p12fT1-(fT1-_w31)st)/(16.ap);

	if (dd<=0.) { InWarning(Form("dd = %e <= 0\n\tdd1 = %e\tdd2 = %e", dd, _dd1, _dd2)); return false; }

	_delta = delb-yy4ststd::sqrt(dd)/(2.*ap);
	fS1 = fT2+_w1+(2._p12r3-4.*_delta)/st;

	if (ap>=0.) { InWarning(Form("ap = %f >= 0", ap)); return false; }

	fJacobian = ds2dt1dt2Constants::PiConstants::Pi/(8._sl1std::sqrt(-ap));

	DebuggingInsideLoop(Form("Jacobian = %e", fJacobian));

	_gram = (1.-std::pow(yy4, 2))*dd/ap;

	_p13 = -t13/2.;
	_p14 = (tau+fS1-fMX2)/2.;
	_p15 = (fS+fT2-fS1-_w2)/2.;
	_p23 = (fS+fT1-fS2-_w1)/2.;
	_p24 = (fS2-tau-fMY2)/2.;
	_p25 = -t25/2.;
	_p34 = (fS1-fMX2-_w4)/2.;
	_p35 = (fS+_w4-fS1-fS2)/2.;
	_p45 = (fS2-_w4-fMY2)/2.;

	_p1k2 = (fS1-fT2-_w1)/2.;
	_p2k1 = st/2.;

	if (_w2!=0.) {
	const double sbb = (fS(fT2-_w52)-_w12t25)/(2.*_w2)+fMY2,
	sdd = _sl1sl6/(2._w2),
	see = (fS(fT2(fS+t25-_w1)-_w1_w52)+fMY2(_w1fMY2-_w12(fT2-_w1)))/_w2;
	if (sbb/sdd>=0.) { s1p = sbb+sdd; s1m = see/s1p; }
	else { s1m = sbb-sdd; s1p = see/s1m; } // 12
	_dd3 = -_w2(s1p-fS1)(s1m-fS1)/4.; // 13
	}
	else { // 14
	s1p = (fS(fT2(fS-fMY2+fT2-_w1)-_w1fMY2)+_w1fMY2(_w1+fMY2-fT2))/(t25(fS-_w12));
	_dd3 = -t25(fS-_w12)(s1p-fS1)/4.;
	}
	// 15
	_acc3 = (s1p-fS1)/(s1p+fS1);

	const double ssb = fT2+_w1-r3(_w31-fT1)/(2.fT1),
	ssd = sl3*sl7/fT1,
	sse = (fT2-_w1)(_w4-fMX2)+(fT2-_w4+_w31)((fT2-_w1)fMX2-(_w4-fMX2)_w1)/fT1;

	if (ssb/ssd>=0.) { s1pp = ssb+ssd; s1pm = sse/s1pp; }
	else { s1pm = ssb-ssd; s1pp = sse/s1pm; } // 16
	// 17
	_dd4 = -fT1(fS1-s1pp)(fS1-s1pm)/4.;
	_acc4 = (fS1-s1pm)/(fS1+s1pm);
	_dd5 = _dd1+_dd3+((_p12(fT1-_w31)/2.-_w1_p2k1)(_p2k1(fT2-_w52)-_w2r3)-_delta(2._p12_p2k1-_w2*(fT1-_w31)))/_p2k1;

	return true;
	}

	bool
	GamGamLL::Orient()
	{
	if (!Pickin() or fJacobian==0.) { InWarning(Form("Pickin failed! dj = %f", fJacobian)); return false; }

	const double re = 1./(2.*fSqS);
	_ep1 = re*(fS+_w12);
	_ep2 = re*(fS-_w12);

	DebuggingInsideLoop(Form(" re = %e\n\t_w12 = %e", re, _w12));
	DebuggingInsideLoop(Form("Incoming particles' energy = %f, %f", _ep1, _ep2));

	_p = re*_sl1;

	_de3 = re*(fS2-fMX2+_w12);
	_de5 = re*(fS1-fMY2-_w12);

	// Final state energies
	const double ep3 = _ep1-_de3, ep5 = _ep2-_de5;
	_ec4 = _de3+_de5;

	if (_ec4<_mc4) { InWarning(Form("_ec4 = %f < _mc4 = %f\n\t==> de3 = %f, de5 = %f", _ec4, _mc4, _de3, _de5)); return false; }

	// What if the protons' momenta are not along the z-axis?
	_pc4 = std::sqrt((std::pow(_ec4, 2)-std::pow(_mc4, 2)));

	if (_pc4==0.) {
	InWarning("_pzc4==0");
	return false;
	}
	const double pp3 = std::sqrt(std::pow(ep3, 2)-fMX2), pt3 = std::sqrt(_dd1/fS)/_p,
	pp5 = std::sqrt(std::pow(ep5, 2)-fMY2), pt5 = std::sqrt(_dd3/fS)/_p;

	DebuggingInsideLoop(Form("Central system's energy: E4 = %f\n\t"
	" momentum: p4 = %f\n\t"
	" invariant mass: m4 = %f\n\t"
	"Outgoing particles' energy: E3 = %f\n\t"
	" E5 = %f",
	_ec4, _pc4, _mc4, ep3, ep5));

	const double st3 = pt3/pp3,
	st5 = pt5/pp5;

	DebuggingInsideLoop(Form("st3 = %e\n\tst5 = %e", st3, st5));

	if (st3>1.) { InWarning(Form("st3 = %e > 1", st3)); return false; }
	if (st5>1.) { InWarning(Form("st5 = %e > 1", st5)); return false; }

	double ct3 = std::sqrt(1.-std::pow(st3, 2)),
	ct5 = std::sqrt(1.-std::pow(st5, 2));

	if (_ep1ep3<_p13) ct3 = -1.;
	if (_ep2ep5>_p25) ct5 = -1.;

	DebuggingInsideLoop(Form("ct3 = %e\n\tct5 = %e", ct3, ct5));

	if (_dd5<0.) { InWarning(Form("dd5 = %f < 0", _dd5)); return false; }

	// Centre of mass system kinematics (theta4 and phi4)
	_pt4 = std::sqrt(_dd5/fS)/_p;
	_st4 = _pt4/_pc4;

	if (_st4>1.) { InWarning(Form("st4 = %f > 1", _st4)); return false; }

	_ct4 = std::sqrt(1.-std::pow(_st4, 2));
	if (_ep1_ec4<_p14) _ct4 = -1.;

	_al4 = 1.-_ct4;
	_be4 = 1.+_ct4;

	if (_ct4<0.) _be4 = std::pow(_st4, 2)/_al4;
	else _al4 = std::pow(_st4, 2)/_be4;

	DebuggingInsideLoop(Form("ct4 = %f\n\tal4 = %f, be4 = %f", _ct4, _al4, _be4));

	const double rr = std::sqrt(-_gram/fS)/(_p*_pt4);
	const double sp3 = rr/pt3, sp5 = -rr/pt5;

	if (fabs(sp3)>1.) { InWarning(Form("sp3 = %e > 1", sp3)); return false; }
	if (fabs(sp5)>1.) { InWarning(Form("sp5 = %e > 1", sp5)); return false; }

	const double cp3 = -std::sqrt(1.-std::pow(sp3, 2)), cp5 = -std::sqrt(1.-std::pow(sp5, 2));

	fP3lab = Particle::Momentum(pp3st3cp3, pp3st3sp3, pp3*ct3, ep3);
	fP5lab = Particle::Momentum(pp5st5cp5, pp5st5sp5, pp5*ct5, ep5);

	const double a1 = fP3lab.Px()-fP5lab.Px();

	DebuggingInsideLoop(Form("Kinematic quantities\n\t"
	"cos(theta3) = %1.4f\tsin(theta3) = %1.4f\tcos( phi3 ) = %1.4f\tsin( phi3 ) = %1.4f\n\t"
	"cos(theta4) = %1.4f\tsin(theta4) = %1.4f\n\t"
	"cos(theta5) = %1.4f\tsin(theta5) = %1.4f\tcos( phi5 ) = %1.4f\tsin( phi5 ) = %1.4f\n\t"
	"a1 = %f",
	ct3, st3, cp3, sp3,
	_ct4, _st4,
	ct5, st5, cp5, sp5, a1));

	if (fabs(_pt4+fP3lab.Px()+fP5lab.Px())<fabs(fabs(a1)-_pt4)) {
	DebuggingInsideLoop(Form("\|pp4+pp3cos(phi3)+pp5cos(phi5)\| < \| \|a1\|-pp4 \|\n\t"
	"pp4 = %f\tpp5 = %f\n\t"
	"cos(phi3) = %f\tcos(phi5) = %f"
	"a1 = %f",
	_pt4, pt5, cp3, cp5, a1));
	return true;
	}
	if (a1<0.) fP5lab.SetP(0, -fP5lab.Px());
	else fP3lab.SetP(0, -fP3lab.Px());
	return true;
	}

	double
	GamGamLL::ComputeOutgoingPrimaryParticlesMasses(double x_, double outmass_, double lepmass_, double *dw_)
	{
	double mx2, dmx2;

	const double wx2min = std::pow(std::max(Particle::GetMassFromPDGId(Particle::Proton)+Particle::GetMassFromPDGId(Particle::PiPlus), fCuts.mxmin), 2),
	//const double wx2min = std::pow(std::max(1.07, fCuts.mxmin), 2),
	wx2max = std::pow(std::min(fSqS-outmass_-2.*lepmass_, fCuts.mxmax), 2);

	Map(x_, wx2min, wx2max, &mx2, &dmx2, "mx2");

	DebuggingInsideLoop(Form("mX^2 in range (%f, %f), x = %f\n\t"
	"mX^2 = %f, d(mX^2) = %f\n\t"
	"mX = %f, d(mX) = %f", wx2min, wx2max, x_, mx2, dmx2, sqrt(mx2), sqrt(dmx2)));

	*dw_ = sqrt(dmx2);
	return sqrt(mx2);
	}

	void
	GamGamLL::BeforeComputeWeight()
	{
	if (!GenericProcess::fIsPointSet) return;

	- Particle *p1 = GetParticle(Particle::IncomingBeam1),
	- *p2 = GetParticle(Particle::IncomingBeam2);
	+ Particle *p1 = GetParticle( Particle::IncomingBeam1 ),
	+ *p2 = GetParticle( Particle::IncomingBeam2 );

	_ep1 = p1->E();
	_mp1 = p1->M();
	_w1 = p1->M2();
	_pp1 = p1->GetMomentum().P();

	_ep2 = p2->E();
	_mp2 = p2->M();
	_w2 = p2->M2();
	_pp2 = p2->GetMomentum().P();

	- const double thetamin = EtaToTheta(fCuts.etamax),
	- thetamax = EtaToTheta(fCuts.etamin);
	- _cotth1 = 1./tan(thetamax*Constants::Pi/180.);
	- _cotth2 = 1./tan(thetamin*Constants::Pi/180.);
	+ const double thetamin = EtaToTheta( fCuts.etamax ),
	+ thetamax = EtaToTheta( fCuts.etamin );
	+ _cotth1 = 1./tan( thetamax*Constants::Pi/180. );
	+ _cotth2 = 1./tan( thetamin*Constants::Pi/180. );
	DebuggingInsideLoop(Form("cot(theta1) = %f\n\tcot(theta2) = %f", _cotth1, _cotth2));

	fMl12 = GetParticle(Particle::CentralParticle1)->M2();
	fMl22 = GetParticle(Particle::CentralParticle2)->M2();

	double m;
	switch (fCuts.kinematics) {
	case Kinematics::ElectronProton:
	{ InError("Electron/Proton case not supported yet!"); }
	case Kinematics::ElasticElastic:
	_dw31 = _dw52 = 0.; break;
	case Kinematics::ElasticInelastic:
	case Kinematics::InelasticElastic:
	m = ComputeOutgoingPrimaryParticlesMasses(x(7), GetParticle(Particle::IncomingBeam1)->M(), GetParticle(Particle::CentralParticle1)->M(), &_dw31);
	GetParticle(Particle::OutgoingBeam1)->SetM(m);
	GetParticle(Particle::OutgoingBeam2)->SetM(Particle::GetMassFromPDGId(GetParticle(Particle::OutgoingBeam2)->GetPDGId())); //FIXME
	break;
	case Kinematics::InelasticInelastic:
	m = ComputeOutgoingPrimaryParticlesMasses(x(7), GetParticle(Particle::IncomingBeam2)->M(), GetParticle(Particle::CentralParticle1)->M(), &_dw31);
	GetParticle(Particle::OutgoingBeam1)->SetM(m);
	m = ComputeOutgoingPrimaryParticlesMasses(x(8), GetParticle(Particle::OutgoingBeam1)->M(), GetParticle(Particle::CentralParticle1)->M(), &_dw52);
	GetParticle(Particle::OutgoingBeam2)->SetM(m);
	break;
	}
	fMX = GetParticle(Particle::OutgoingBeam1)->M();
	fMY = GetParticle(Particle::OutgoingBeam2)->M();
	- fMX2 = std::pow(fMX, 2);
	- fMY2 = std::pow(fMY, 2);
	+ fMX2 = fMX*fMX;
	+ fMY2 = fMY*fMY;
	}

	double
	GamGamLL::ComputeWeight()
	{
	// WARNING ====> PP5-->_pt5
	// P5-->_pp5
	double weight;
	double dw4;
	double wmin, wmax;
	double stg, cpg, spg, ctg;

	double qcx, qcz;
	double pc6x, pc6z;

	double b1, b2, b3;
	double c1, c2, c3;
	double h1, h2, hq;
	double r12, r13, r22, r23;

	bool lcut, lmu1, lmu2;

	weight = 0.;

	if (!fIsOutStateSet) { InWarning("Output state not set!"); return 0.; }

	if (fCuts.wmax<0) fCuts.wmax = fS;

	// The minimal energy for the central system is its outgoing leptons' mass energy (or wmin_ if specified)
	wmin = std::pow(GetParticle(Particle::CentralParticle1)->M()+GetParticle(Particle::CentralParticle2)->M(),2);
	if (fabs(wmin)<fabs(fCuts.wmin)) wmin = fCuts.wmin;

	// The maximal energy for the central system is its CM energy with the outgoing particles' mass energy substracted (or _wmax if specified)
	wmax = std::pow(fSqS-fMX-fMY,2);
	DebuggingInsideLoop(Form("sqrt(s)=%f\n\tm(X1)=%f\tm(X2)=%f", fSqS, fMX, fMY));
	if (fabs(wmax)>fabs(fCuts.wmax)) wmax = fCuts.wmax;

	DebuggingInsideLoop(Form("wmin = %f\n\twmax = %f\n\twmax/wmin = %f", wmin, wmax, wmax/wmin));

	Map(x(4), wmin, wmax, &_w4, &dw4, "w4");
	_mc4 = std::sqrt(_w4);

	DebuggingInsideLoop(Form("Computed value for w4 = %f -> mc4 = %f", _w4, _mc4));

	if (!Orient()) return 0.;

	if (fT1>0.) { InWarning(Form("t1 = %f > 0", fT1)); return 0.; }
	if (fT2>0.) { InWarning(Form("t2 = %f > 0", fT2)); return 0.; }
	if (fJacobian==0.) { InWarning(Form("dj = %f", fJacobian)); return 0.; }

	const double ecm6 = (_w4+fMl12-fMl22)/(2.*_mc4);
	const double pp6cm = std::sqrt(std::pow(ecm6, 2)-fMl12);

	fJacobian = dw4pp6cm/(_mc4Constants::sconstbfS);

	// Let the most obscure part of this code begin...

	const double e1mp1 = _w1/(_ep1+_p),
	e3mp3 = fMX2/(fP3lab.E()+fP3lab.P());

	const double al3 = std::pow(sin(fP3lab.Theta()), 2)/(1.+(fP3lab.Theta()));

	// 2-photon system kinematics ?!
	const double eg = (_w4+fT1-fT2)/(2.*_mc4);
	double pg = std::sqrt(std::pow(eg, 2)-fT1);
	const double pgx = -fP3lab.Px()_ct4-_st4(_de3-e1mp1+e3mp3+fP3lab.P()*al3),
	pgy = -fP3lab.Py(),
	pgz = _mc4_de3/(_ec4+_pc4)-_ec4_de3_al4/_mc4-fP3lab.Px()_ec4_st4/_mc4+_ec4_ct4/_mc4(fP3lab.P()al3+e3mp3-e1mp1);

	DebuggingInsideLoop(Form("pg3 = (%f, %f, %f)\n\t"
	"pg3^2 = %f",
	pgx, pgy, pgz,
	std::sqrt(std::pow(pgx, 2)+std::pow(pgy, 2)+std::pow(pgz, 2))
	));

	const double pgp = std::sqrt(std::pow(pgx, 2)+std::pow(pgy, 2)), // outgoing proton (3)'s transverse momentum
	pgg = std::sqrt(std::pow(pgp, 2)+std::pow(pgz, 2)); // outgoing proton (3)'s momentum
	if (pgg>pgp*.9 && pgg>pg) { pg = pgg; } //FIXME ???

	// Phi angle for the 2-photon system ?!
	cpg = pgx/pgp;
	spg = pgy/pgp;

	// Theta angle for the 2-photon system ?!
	stg = pgp/pg;
	ctg = std::sqrt(1.-std::pow(stg, 2));
	if (pgz<0.) ctg *= -1.;

	double xx6 = x(5);

	const double amap = (_w4-fT1-fT2)/2.,
	bmap = std::sqrt((std::pow(_w4-fT1-fT2, 2)-4.fT1fT2)(1.-4.fMl12/_w4))/2.,
	ymap = (amap+bmap)/(amap-bmap),
	beta = std::pow(ymap, (double)(2.*xx6-1.));
	xx6 = (amap/bmap*(beta-1.)/(beta+1.)+1.)/2.;
	if (xx6>1.) xx6 = 1.;
	if (xx6<0.) xx6 = 0.;

	DebuggingInsideLoop(Form("amap = %f\n\tbmap = %f\n\tymap = %f\n\tbeta = %f", amap, bmap, ymap, beta));

	// 3D rotation of the first outgoing lepton wrt the CM system
	const double theta6cm = acos(1.-2.*xx6);

	// match the Jacobian
	fJacobian = (((amap+bmapcos(theta6cm))(amap-bmapcos(theta6cm))/amap/bmap*log(ymap))/2.);

	DebuggingInsideLoop(Form("Jacobian = %e", fJacobian));

	DebuggingInsideLoop(Form("ctcm6 = %f\n\tstcm6 = %f", cos(theta6cm), sin(theta6cm)));

	const double phi6cm = 2.Constants::Pix(6);

	// First outgoing lepton's 3-momentum in the centre of mass system
	Particle::Momentum p6cm = Particle::Momentum::FromPThetaPhi(pp6cm, theta6cm, phi6cm);

	DebuggingInsideLoop(Form("p3cm6 = (%f, %f, %f)", p6cm.Px(), p6cm.Py(), p6cm.Pz()));

	h1 = stgp6cm.Pz()+ctgp6cm.Px();

	pc6z = ctgp6cm.Pz()-stgp6cm.Px();
	pc6x = cpgh1-spgp6cm.Py();

	qcx = 2.*pc6x;
	qcz = 2.*pc6z;
	// qcy == QCY is never defined

	double p6x, p6y, p6z;
	const double el6 = (_ec4ecm6+_pc4pc6z)/_mc4;
	h2 = (_ec4pc6z+_pc4ecm6)/_mc4;

	DebuggingInsideLoop(Form("h1 = %f\n\th2 = %f", h1, h2));

	// First outgoing lepton's 3-momentum
	p6x = _ct4pc6x+_st4h2;
	p6y = cpgp6cm.Py()+spgh1;
	p6z = _ct4h2-_st4pc6x;

	// first outgoing lepton's kinematics
	fP6cm = Particle::Momentum(p6x, p6y, p6z, el6);
	DebuggingInsideLoop(Form("E6(cm) = %f\n\tP6(cm) = (%f, %f, %f)", el6, p6x, p6y, p6z));

	hq = _ec4*qcz/_mc4;

	const Particle::Momentum qve(
	_ct4qcx+_st4hq,
	2.*p6y,
	_ct4hq-_st4qcx,
	_pc4*qcz/_mc4 // energy
	);

	// Available energy for the second lepton is the 2-photon system's energy with the first lepton's energy removed
	const double el7 = _ec4-el6;

	DebuggingInsideLoop(Form("Outgoing kinematics\n\t"
	" first outgoing lepton: p = %f, E = %f\n\t"
	"second outgoing lepton: p = %f, E = %f",
	fP6cm.P(), fP6cm.E(), fP7cm.P(), fP6cm.E()));

	double p7x, p7y, p7z;
	// Second outgoing lepton's 3-momentum
	p7x = _pt4-p6x;
	p7y = -p6y;
	p7z = _pc4*_ct4-p6z;

	// second outgoing lepton's kinematics
	fP7cm = Particle::Momentum(p7x, p7y, p7z, el7);

	//fP6cm = Particle::Momentum(pl6st6cp6, pl6st6sp6, pl6*ct6, el6);
	//fP7cm = Particle::Momentum(pl7st7cp7, pl7st7sp7, pl7*ct7, el7);

	_q1dq = eg(2.ecm6-_mc4)-2.pgp6cm.Pz();
	_q1dq2 = (_w4-fT1-fT2)/2.;

	const double phi3 = fP3lab.Phi(), cp3 = cos(phi3), sp3 = sin(phi3),
	phi5 = fP5lab.Phi(), cp5 = cos(phi5), sp5 = sin(phi5);
	//std::cout << ">>> " << fP3lab.Pt() << "/" << fP5lab.Pt() << std::endl;

	_bb = fT1fT2+(_w4std::pow(sin(theta6cm), 2)+4.fMl12std::pow(cos(theta6cm), 2))*std::pow(pg, 2);

	c1 = (qve.Px()sp3-qve.Py()cp3)*fP3lab.Pt();
	c2 = (qve.Pz()_ep1-qve.E()_p)*fP3lab.Pt();
	c3 = (_w31std::pow(_ep1, 2)+2._w1_de3_ep1-_w1std::pow(_de3, 2)+std::pow(fP3lab.Pt(), 2)std::pow(_ep1, 2))/(fP3lab.E()_p+fP3lab.Pz()_ep1);

	b1 = (qve.Px()sp5-qve.Py()cp5)*fP5lab.Pt();
	b2 = (qve.Pz()_ep2+qve.E()_p)*fP5lab.Pt();
	b3 = (_w52std::pow(_ep2, 2)+2._w2_de5_ep2-_w2std::pow(_de5, 2)+std::pow(fP5lab.Pt()_ep2, 2))/(_ep2fP5lab.Pz()-fP5lab.E()_p); //OK

	r12 = c2sp3+qve.Py()c3;
	r13 = -c2cp3-qve.Px()c3;

	DebuggingInsideLoop(Form("qve = (%f, %f, %f, %f)", qve.E(), qve.Px(), qve.Py(), qve.Pz()));

	r22 = b2sp5+qve.Py()b3;
	r23 = -b2cp5-qve.Px()b3;

	_epsi = _p12c1b1+r12r22+r13r23;

	_g5 = _w1*std::pow(c1, 2)+std::pow(r12, 2)+std::pow(r13, 2);
	_g6 = _w2*std::pow(b1, 2)+std::pow(r22, 2)+std::pow(r23, 2);

	_a5 = -(qve.Px()cp3+qve.Py()sp3)fP3lab.Pt()_p1k2-(_ep1qve.E()-_pqve.Pz())(cp3cp5+sp3sp5)fP3lab.Pt()fP5lab.Pt()+(_de5qve.Pz()+qve.E()(_p+fP5lab.Pz()))c3;
	_a6 = -(qve.Px()cp5+qve.Py()sp5)fP5lab.Pt()_p2k1-(_ep2qve.E()+_pqve.Pz())(cp3cp5+sp3sp5)fP3lab.Pt()fP5lab.Pt()+(_de3qve.Pz()-qve.E()(_p-fP3lab.Pz()))b3;

	DebuggingInsideLoop(Form("a5 = %f\n\ta6 = %f", _a5, _a6));

	//std::cout << _a5 << ">>>" << _a6 << std::endl;

	////////////////////////////////////////////////////////////////
	// END of GAMGAMLL subroutine in the FORTRAN version
	////////////////////////////////////////////////////////////////

	const Particle::Momentum cm = GetParticle(Particle::IncomingBeam1)->GetMomentum()
	+GetParticle(Particle::IncomingBeam2)->GetMomentum();

	////////////////////////////////////////////////////////////////
	// INFO from f.f
	////////////////////////////////////////////////////////////////

	const double gamma = cm.E()/fSqS, betgam = cm.Pz()/fSqS;

	if (fCuts.mode==Kinematics::NoCuts) {
	Debugging(Form("No cuts applied on the outgoing leptons kinematics!"));
	}
	// Kinematics computation for both leptons

	fP6cm.BetaGammaBoost(gamma, betgam);
	fP7cm.BetaGammaBoost(gamma, betgam);

	lcut = false; // Event discarded by default
	const double cott6 = fP6cm.Pz()/fP6cm.Pt(), cott7 = fP7cm.Pz()/fP7cm.Pt();

	// Cuts on outgoing leptons' kinematics

	lmu1 = cott6>=_cotth1
	and cott6<=_cotth2
	and (fP6cm.Pt()>=fCuts.ptmin or fCuts.ptmin<=0.)
	and (fP6cm.Pt()<=fCuts.ptmax or fCuts.ptmax<=0.)
	and (fP6cm.E()>=fCuts.emin or fCuts.emin <=0.)
	and (fP6cm.E()<=fCuts.emax or fCuts.emax <=0.);
	lmu2 = cott7>=_cotth1
	and cott7<=_cotth2
	and (fP7cm.Pt()>=fCuts.ptmin or fCuts.ptmin<=0.)
	and (fP7cm.Pt()<=fCuts.ptmax or fCuts.ptmax<=0.)
	and (fP7cm.E()>=fCuts.emin or fCuts.emin <=0.)
	and (fP7cm.E()<=fCuts.emax or fCuts.emax <=0.);

	switch (fCuts.mode) {
	case Kinematics::NoCuts: default:
	lcut = true; break;
	case Kinematics::VermaserenCuts: // Vermaseren's hypothetical detector cuts
	{
	const double cost6 = fP6cm.Pz()/fP6cm.P(), cost7 = fP7cm.Pz()/fP7cm.P();
	lcut = ((fabs(cost6)<=0.75 and _pt_l6>=1.) or (fabs(cost6)<=0.95 and fabs(cost6)>0.75 and fabs(fP6cm.Pz())>1.)) and
	((fabs(cost7)<=0.75 and _pt_l7>=1.) or (fabs(cost7)<=0.95 and fabs(cost7)>0.75 and fabs(fP7cm.Pz())>1.));
	}
	break;
	case Kinematics::BothParticles: lcut = lmu1 and lmu2; break;
	case Kinematics::OneParticle: lcut = lmu1 or lmu2; break;
	}
	if (!lcut) { return 0.; } // Dismiss the cuts-failing events in the cross-section computation

	// Cut on mass of final hadronic system (MX)
	if (fCuts.kinematics>1) {
	if (fMX<fCuts.mxmin or fMX>fCuts.mxmax) return 0.;
	if (fCuts.kinematics==4) {
	if (fMY<fCuts.mxmin or fMY>fCuts.mxmax) return 0.;
	}
	}

	// Cut on the proton's Q2 (first photon propagator T1)
	if ((fCuts.q2max!=-1. and fT1<-fCuts.q2max) or fT1>-fCuts.q2min) { return 0.; }

	weight = Constants::GeV2toBarn*fJacobian;
	switch (fCuts.kinematics) { // FIXME inherited from CDF version
	default: case 0: weight *= PeriPP(1, 2); break; // ep case
	case 1: weight *= PeriPP(2, 2); break; // elastic case
	case 2: case 3: weight = PeriPP(3, 2)std::pow(_dw31,2); break; // single-dissociative case
	case 4: weight = PeriPP(3, 3)std::pow(_dw31*_dw52,2); break; // double-dissociative case
	}

	return weight;
	}

	void
	GamGamLL::FillKinematics(bool)
	{
	const Particle::Momentum cm = GetParticle(Particle::IncomingBeam1)->GetMomentum()
	+GetParticle(Particle::IncomingBeam2)->GetMomentum();
	const double gamma = cm.E()/fSqS, betgam = cm.Pz()/fSqS;

	double ranphi;
	int rany, ransign/, ranz/;

	// debugging variables
	double gmux, gmuy, gmuw, gmunu;

	// Needed to parametrise a random rotation around z-axis
	rany = ((double)rand()>=.5*RAND_MAX) ? 1 : -1;
	ransign = ((double)rand()>=.5*RAND_MAX) ? 1 : -1;
	ranphi = ((double)rand()/RAND_MAX)2.Constants::Pi;
	/*ranz = 1;
	if (symmetrise_) {
	ranz = ((double)rand()>=.5*RAND_MAX) ? 1 : -1;
	//_pp3 *= ranz;
	//_pp5 *= ranz;
	}*/

	// First incoming proton
	Particle* ip1 = GetParticle(Particle::IncomingBeam1);
	Particle::Momentum plab_ip1(0., 0., _p, _ep1);
	plab_ip1.BetaGammaBoost(gamma, betgam);
	ip1->SetMomentum(plab_ip1);
	// InError("Invalid incoming proton 1");

	// Second incoming proton
	Particle* ip2 = GetParticle(Particle::IncomingBeam2);
	Particle::Momentum plab_ip2(0., 0., -_p, _ep2);
	plab_ip2.BetaGammaBoost(gamma, betgam);
	ip2->SetMomentum(plab_ip2);
	// InError("Invalid incoming proton 2");

	// First outgoing proton
	Particle* op1 = GetParticle(Particle::OutgoingBeam1);
	fP3lab.BetaGammaBoost(gamma, betgam);
	fP3lab.RotatePhi(ranphi, rany);
	op1->SetMomentum(fP3lab);
	// InError("Invalid outgoing proton 1");
	if (fCuts.kinematics>1) { op1->status = Particle::Undecayed; op1->SetM(fMX); } // fragmenting remnants
	else { op1->status = Particle::FinalState; op1->SetM(); } // stable proton

	// Second outgoing proton
	Particle* op2 = GetParticle(Particle::OutgoingBeam2);
	fP5lab.BetaGammaBoost(gamma, betgam);
	fP5lab.RotatePhi(ranphi, rany);
	op2->SetMomentum(fP5lab);
	// InError("Invalid outgoing proton 2");
	if (fCuts.kinematics==4) { op2->status = Particle::Undecayed; op2->SetM(fMY); } // fragmenting remnants
	else { op2->status = Particle::FinalState; op2->SetM(); } // stable proton

	// First incoming photon
	// Equivalent in LPAIR : PLAB(x, 3)
	Particle* ph1 = GetParticle(Particle::Parton1);
	Particle::Momentum plab_ph1 = plab_ip1-fP3lab;
	plab_ph1.RotatePhi(ranphi, rany);
	ph1->SetMomentum(plab_ph1);
	////InError("Invalid photon 1");
	ph1->charge = 0;
	ph1->status = Particle::Incoming; // "incoming beam"

	// Second incoming photon
	// Equivalent in LPAIR : PLAB(x, 4)
	Particle* ph2 = GetParticle(Particle::Parton2);
	Particle::Momentum plab_ph2 = plab_ip2-fP5lab;
	plab_ph2.RotatePhi(ranphi, rany);
	ph2->SetMomentum(plab_ph2);
	////InError("Invalid photon 2");
	ph2->charge = 0;
	ph2->status = Particle::Incoming; // "incoming beam"

	// Central (two-photon) system
	Particle* cs = GetParticle(Particle::CentralSystem);
	cs->status = Particle::Incoming;

	Particle::Role role_ol1, role_ol2;
	if (ransign<0) { role_ol1 = Particle::CentralParticle1; role_ol2 = Particle::CentralParticle2; }
	else { role_ol1 = Particle::CentralParticle2; role_ol2 = Particle::CentralParticle1; }

	// First outgoing lepton
	Particle* ol1 = GetParticle(role_ol1);
	ol1->SetPDGId(ol1->GetPDGId(), ransign);
	fP6cm.RotatePhi(ranphi, rany);
	ol1->SetMomentum(fP6cm);
	// InError("Invalid outgoing lepton 1");
	ol1->status = Particle::FinalState;
	ol1->SetM(); //FIXME

	// Second outgoing lepton
	Particle* ol2 = GetParticle(role_ol2);
	ol2->SetPDGId(ol2->GetPDGId(), -ransign);
	fP7cm.RotatePhi(ranphi, rany);
	ol2->SetMomentum(fP7cm);
	ol2->status = Particle::FinalState;
	ol2->SetM(); //FIXME

	if (Logger::GetInstance()->Level>=Logger::DebugInsideLoop) {
	gmux = -fT2/(_ep1_eg2-_pp1_p3_g2[2])/2.;
	gmuy = plab_ip1.FourProduct(plab_ph2)/plab_ip2.FourProduct(plab_ph2);
	gmuw = (plab_ip1+plab_ph2).M();
	gmunu = gmuy2.Particle::GetMassFromPDGId(Particle::Proton)/_ep1/_ep2;
	DebuggingInsideLoop(Form(" gmux = %f\n\t"
	" gmux = %f\n\t"
	" gmuw = %f\n\t"
	"gmunu = %f", gmux, gmuy, gmuw, gmunu));
	}
	//fEvent->Dump();
	}

	double
	GamGamLL::PeriPP(int nup_, int ndown_)
	{
	DebuggingInsideLoop(Form(" Nup = %d\n\tNdown = %d", nup_, ndown_));

	FormFactors fp1, fp2;

	- switch(nup_) {
	+ switch( nup_ ) {
	case 1: fp1 = TrivialFormFactors(); break; // electron (trivial) form factor
	- case 2: fp1 = ElasticFormFactors(-fT1, _w1); break; // proton elastic form factor
	- case 4: fp1 = FioreBrasseFormFactors(-fT1, _w1, fMX2); break; // does not exist in CDF version
	- default: fp1 = SuriYennieFormFactors(-fT1, _w1, fMX2); break;
	+ case 2: fp1 = ElasticFormFactors( -fT1, _w1 ); break; // proton elastic form factor
	+ case 4: fp1 = FioreBrasseFormFactors( -fT1, _w1, fMX2 ); break; // does not exist in CDF version
	+ //case 5: fp1 = SzczurekUleschenkoFormFactors( -fT1, _w1, fMX2 ); break;
	+ default: fp1 = SuriYennieFormFactors( -fT1, _w1, fMX2 ); break;
	}

	- switch(ndown_) {
	+ switch( ndown_ ) {
	case 1: fp2 = TrivialFormFactors(); break; // electron (trivial) form factor
	- case 2: fp2 = ElasticFormFactors(-fT2, _w2); break; // proton elastic form factor
	- case 4: fp2 = FioreBrasseFormFactors(-fT2, _w2, fMY2); break; // low-Q2 inelastic form factor
	- default: fp2 = SuriYennieFormFactors(-fT2, _w2, fMY2); break;
	+ case 2: fp2 = ElasticFormFactors( -fT2, _w2 ); break; // proton elastic form factor
	+ case 4: fp2 = FioreBrasseFormFactors( -fT2, _w2, fMY2 ); break; // low-Q2 inelastic form factor
	+ //case 5: fp2 = SzczurekUleschenkoFormFactors( -fT2, _w2, fMY2 ); break;
	+ default: fp2 = SuriYennieFormFactors( -fT2, _w2, fMY2 ); break;
	}

	- DebuggingInsideLoop(Form("u1 = %f\n\tu2 = %f\n\tv1 = %f\n\tv2 = %f", fp1.FM, fp1.FE, fp2.FM, fp2.FE));
	+ DebuggingInsideLoop( Form( "u1 = %f\n\tu2 = %f\n\tv1 = %f\n\tv2 = %f", fp1.FM, fp1.FE, fp2.FM, fp2.FE ) );

	- const double qqq = std::pow(_q1dq, 2),
	+ const double qqq = _q1dq*_q1dq,
	qdq = 4.*fMl12-_w4;
	- const double t11 = 64. ( _bb(qqq-_g4-qdq(fT1+fT2+2.fMl12))-2.(fT1+2.fMl12)(fT2+2.fMl12)qqq)fT1*fT2,
	- t12 = 128.(-_bb(_dd2+_g6)-2.(fT1+2.fMl12)(_sa2qqq+std::pow(_a6, 2)))*fT1,
	- t21 = 128.(-_bb(_dd4+_g5)-2.(fT2+2.fMl12)(_sa1qqq+std::pow(_a5, 2)))*fT2,
	- t22 = 512.( _bb(std::pow(_delta, 2)-_gram)-std::pow(_epsi-_delta(qdq+_q1dq2), 2)-_sa1std::pow(_a6, 2)-_sa2std::pow(_a5, 2)-_sa1_sa2*qqq);
	+ const double t11 = 64. ( _bb( qqq-_g4-qdq( fT1+fT2+2.fMl12 ) )-2.( fT1+2.fMl12 )( fT2+2.fMl12 )qqq ) fT1*fT2,
	+ t12 = 128.( -_bb( _dd2+_g6 )-2.( fT1+2.fMl12 )( _sa2qqq+_a6_a6 ) ) fT1,
	+ t21 = 128.( -_bb( _dd4+_g5 )-2.( fT2+2.fMl12 )( _sa1qqq+_a5_a5 ) ) fT2,
	+ t22 = 512.( _bb( _delta_delta-_gram )-std::pow(_epsi-_delta(qdq+_q1dq2), 2)-_sa1_a6_a6-_sa2_a5_a5-_sa1_sa2qqq );

	const double peripp = ( fp1.FMfp2.FMt11
	+fp1.FEfp2.FMt21
	+fp1.FMfp2.FEt12
	- +fp1.FEfp2.FEt22) / pow(2.fT1fT2*_bb, 2);
	+ +fp1.FEfp2.FEt22 ) / pow( 2.fT1fT2*_bb, 2 );

	DebuggingInsideLoop(Form("t11 = %5.2f\tt12 = %5.2f\n\t"
	"t21 = %5.2f\tt22 = %5.2f\n\t"
	"=> PeriPP = %e", t11, t12, t21, t22, peripp));

	return peripp;
	}
	diff --git a/processes/GenericKTProcess.cpp b/processes/GenericKTProcess.cpp
	index e9d9ba4..6bdfc12 100644
	--- a/processes/GenericKTProcess.cpp
	+++ b/processes/GenericKTProcess.cpp
	@@ -1,202 +1,202 @@
	#include "GenericKTProcess.h"

	GenericKTProcess::GenericKTProcess( const std::string& name_,
	const unsigned int& num_user_dimensions_,
	const Particle::ParticleCode& ip1_,
	const Particle::ParticleCode& op1_,
	const Particle::ParticleCode& ip2_,
	const Particle::ParticleCode& op2_) :
	GenericProcess( name_+" (kT-factorisation approach)" ),
	kNumRequiredDimensions( 4 ), kNumUserDimensions( num_user_dimensions_ ),
	kIntermediatePart1( ip1_ ), kProducedPart1( op1_ )
	{
	if ( ip2_==Particle::invalidParticle ) kIntermediatePart2 = kIntermediatePart1;
	if ( op2_==Particle::invalidParticle ) kProducedPart2 = kProducedPart1;
	}

	GenericKTProcess::~GenericKTProcess()
	{}

	void
	GenericKTProcess::AddEventContent()
	{
	IncomingState is; OutgoingState os;
	is.insert( ParticleWithRole( Particle::IncomingBeam1, Particle::Proton ) );
	is.insert( ParticleWithRole( Particle::IncomingBeam2, Particle::Proton ) );
	is.insert( ParticleWithRole( Particle::Parton1, kIntermediatePart1 ) );
	is.insert( ParticleWithRole( Particle::Parton2, kIntermediatePart2 ) );
	os.insert( ParticleWithRole( Particle::OutgoingBeam1, Particle::Proton ) );
	os.insert( ParticleWithRole( Particle::OutgoingBeam2, Particle::Proton ) );
	os.insert( ParticleWithRole( Particle::CentralParticle1, kProducedPart1 ) );
	os.insert( ParticleWithRole( Particle::CentralParticle2, kProducedPart2 ) );
	GenericProcess::SetEventContent( is, os );
	}

	unsigned int
	GenericKTProcess::GetNdim( const Kinematics::ProcessMode& process_mode_ ) const
	{
	switch ( process_mode_ ) {
	default:
	case Kinematics::ElasticElastic: return kNumRequiredDimensions+kNumUserDimensions;
	case Kinematics::ElasticInelastic:
	case Kinematics::InelasticElastic: return kNumRequiredDimensions+kNumUserDimensions+1;
	case Kinematics::InelasticInelastic: return kNumRequiredDimensions+kNumUserDimensions+2;
	}
	}

	void
	GenericKTProcess::AddPartonContent()
	{
	// Incoming partons
	fQT1 = exp( fLogQmin+( fLogQmax-fLogQmin )*x( 0 ) );
	fQT2 = exp( fLogQmin+( fLogQmax-fLogQmin )*x( 1 ) );
	fPhiQT1 = 2.Constants::Pix( 2 );
	fPhiQT2 = 2.Constants::Pix( 3 );
	DebuggingInsideLoop( Form( "photons transverse virtualities (qt):\n\t"
	" mag = %f / %f (%.2f < log(qt) < %.2f)\n\t"
	" phi = %f / %f",
	fQT1, fQT2, fLogQmin, fLogQmax, fPhiQT1, fPhiQT2 ) );
	}

	double
	GenericKTProcess::ComputeWeight()
	{
	AddPartonContent();
	PrepareKTKinematics();
	ComputeOutgoingPrimaryParticlesMasses();

	const double jac = ComputeJacobian(),
	integrand = ComputeKTFactorisedMatrixElement(),
	weight = jac*integrand;
	DebuggingInsideLoop( Form( "Jacobian = %f\n\tIntegrand = %f\n\tdW = %f", jac, integrand, weight ) );

	return weight;
	}

	void
	GenericKTProcess::ComputeOutgoingPrimaryParticlesMasses()
	{
	const unsigned int op_index = kNumRequiredDimensions+kNumUserDimensions;
	switch ( fCuts.kinematics ) {
	case Kinematics::ElectronProton: default: {
	InError( "This kT factorisation process is intended for p-on-p collisions! Aborting!" );
	exit( 0 ); } break;
	case Kinematics::ElasticElastic:
	fMX = GetParticle( Particle::IncomingBeam1 )->M();
	fMY = GetParticle( Particle::IncomingBeam2 )->M();
	break;
	case Kinematics::ElasticInelastic:
	fMX = GetParticle( Particle::IncomingBeam1 )->M();
	fMY = fCuts.mxmin+( fCuts.mxmax-fCuts.mxmin )*x( op_index );
	break;
	case Kinematics::InelasticElastic:
	fMX = fCuts.mxmin+( fCuts.mxmax-fCuts.mxmin )*x( op_index );
	fMY = GetParticle( Particle::IncomingBeam2 )->M();
	break;
	case Kinematics::InelasticInelastic:
	fMX = fCuts.mxmin+( fCuts.mxmax-fCuts.mxmin )*x( op_index );
	fMY = fCuts.mxmin+( fCuts.mxmax-fCuts.mxmin )*x( op_index+1 );
	break;
	}
	DebuggingInsideLoop( Form( "outgoing remnants invariant mass: %f / %f (%.2f < M(X/Y) < %.2f)", fMX, fMY, fCuts.mxmin, fCuts.mxmax ) );
	}

	void
	GenericKTProcess::ComputeIncomingFluxes( double x1, double q1t2, double x2, double q2t2 )
	{
	fFlux1 = fFlux2 = 0.;
	switch ( fCuts.kinematics ) {
	case Kinematics::ElasticElastic:
	- fFlux1 = PhotonFluxes::ProtonElastic(x1, q1t2);
	- fFlux2 = PhotonFluxes::ProtonElastic(x2, q2t2);
	+ fFlux1 = PhotonFluxes::ProtonElastic( x1, q1t2 );
	+ fFlux2 = PhotonFluxes::ProtonElastic( x2, q2t2 );
	break;
	case Kinematics::ElasticInelastic:
	- fFlux1 = PhotonFluxes::ProtonElastic(x1, q1t2);
	- fFlux2 = PhotonFluxes::ProtonInelastic(x2, q2t2, fMY);
	+ fFlux1 = PhotonFluxes::ProtonElastic( x1, q1t2 );
	+ fFlux2 = PhotonFluxes::ProtonInelastic( x2, q2t2, fMY );
	break;
	case Kinematics::InelasticElastic:
	- fFlux1 = PhotonFluxes::ProtonInelastic(x1, q1t2, fMX);
	- fFlux2 = PhotonFluxes::ProtonElastic(x2, q2t2);
	+ fFlux1 = PhotonFluxes::ProtonInelastic( x1, q1t2, fMX );
	+ fFlux2 = PhotonFluxes::ProtonElastic( x2, q2t2 );
	break;
	case Kinematics::InelasticInelastic:
	- fFlux1 = PhotonFluxes::ProtonInelastic(x1, q1t2, fMX);
	- fFlux2 = PhotonFluxes::ProtonInelastic(x2, q2t2, fMY);
	+ fFlux1 = PhotonFluxes::ProtonInelastic( x1, q1t2, fMX );
	+ fFlux2 = PhotonFluxes::ProtonInelastic( x2, q2t2, fMY );
	break;
	default: return;
	}
	if ( fFlux1<1.e-20 ) fFlux1 = 0.;
	if ( fFlux2<1.e-20 ) fFlux2 = 0.;
	DebuggingInsideLoop( Form( "Form factors: %e / %e", fFlux1, fFlux2 ) );
	}

	void
	GenericKTProcess::FillKinematics( bool )
	{
	FillPrimaryParticlesKinematics();
	FillCentralParticlesKinematics();
	}

	void
	GenericKTProcess::FillPrimaryParticlesKinematics()
	{
	//=================================================================
	// outgoing protons
	//=================================================================
	Particle *op1 = GetParticle( Particle::OutgoingBeam1 ),
	*op2 = GetParticle( Particle::OutgoingBeam2 );
	// off-shell particles (remnants?)
	bool os1 = false, os2 = false;
	switch ( fCuts.kinematics ) {
	case Kinematics::ElectronProton: default: {
	InError( "This kT factorisation process is intended for p-on-p collisions! Aborting!" );
	exit(0); } break;
	case Kinematics::ElasticElastic:
	op1->status = Particle::FinalState;
	op2->status = Particle::FinalState;
	break;
	case Kinematics::ElasticInelastic:
	op1->status = Particle::FinalState;
	op2->status = Particle::Undecayed; op2->SetM(); os2 = true;
	break;
	case Kinematics::InelasticElastic:
	op1->status = Particle::Undecayed; op1->SetM(); os1 = true;
	op2->status = Particle::FinalState;
	break;
	case Kinematics::InelasticInelastic:
	op1->status = Particle::Undecayed; op1->SetM(); os1 = true;
	op2->status = Particle::Undecayed; op2->SetM(); os2 = true;
	break;
	}

	if ( !op1->SetMomentum( fPX, os1 ) ) { InError( Form( "Invalid outgoing proton 1: energy: %.2f", fPX.E() ) ); }
	if ( !op2->SetMomentum( fPY, os2 ) ) { InError( Form( "Invalid outgoing proton 2: energy: %.2f", fPY.E() ) ); }

	//=================================================================
	// incoming partons (photons, pomerons, ...)
	//=================================================================
	//FIXME ensure the validity of this approach
	Particle *g1 = GetParticle( Particle::Parton1 ),
	*g2 = GetParticle( Particle::Parton2 );
	g1->SetMomentum( GetParticle( Particle::IncomingBeam1 )->GetMomentum()-fPX, true);
	g1->status = Particle::Incoming;
	g2->SetMomentum( GetParticle( Particle::IncomingBeam2 )->GetMomentum()-fPY, true);
	g2->status = Particle::Incoming;
	}

	double
	GenericKTProcess::MinimalJacobian() const
	{
	double jac = 1.;
	jac = ( fLogQmax-fLogQmin )fQT1; // d(q1t) . q1t
	jac = ( fLogQmax-fLogQmin )fQT2; // d(q2t) . q2t
	jac = 2.Constants::Pi; // d(phi1)
	jac = 2.Constants::Pi; // d(phi2)
	switch ( fCuts.kinematics ) {
	case Kinematics::ElasticElastic: default: break;
	case Kinematics::ElasticInelastic: jac = ( fCuts.mxmax-fCuts.mxmin )2.*fMY; break;
	case Kinematics::InelasticElastic: jac = ( fCuts.mxmax-fCuts.mxmin )2.*fMX; break;
	case Kinematics::InelasticInelastic: jac = ( fCuts.mxmax-fCuts.mxmin )2.*fMX;
	jac = ( fCuts.mxmax-fCuts.mxmin )2.*fMY; break;
	} // d(mx/y**2)
	return jac;
	}
	diff --git a/processes/GenericProcess.h b/processes/GenericProcess.h
	index 8d77fad..b65276d 100644
	--- a/processes/GenericProcess.h
	+++ b/processes/GenericProcess.h
	@@ -1,200 +1,203 @@
	#ifndef GenericProcess_h
	#define GenericProcess_h

	#include "physics/Event.h"
	#include "physics/Kinematics.h"
	#include "physics/Physics.h"

	/**
	* Class template to define any process to compute using this MC integrator/events generator
	* \author Laurent Forthomme <laurent.forthomme@cern.ch>
	* \date Jan 2014
	*/
	class GenericProcess
	{
	public:

	/// Proton structure function to be used in the outgoing state description
	enum StructureFunctions {
	Electron = 1,
	ElasticProton = 2,
	SuriYennie = 11,
	SuriYennieLowQ2 = 12,
	SzczurekUleshchenko = 15,
	FioreVal = 101,
	FioreSea = 102,
	Fiore = 103
	};
	/// Human-readable format of a structure function object
	friend std::ostream& operator<<( std::ostream& os, const GenericProcess::StructureFunctions& sf );
	+ /// Human-readable format dump of a GenericProcess object
	friend std::ostream& operator<<( std::ostream& os, const GenericProcess& proc );
	+ /// Human-readable format dump of a pointer to a GenericProcess object
	friend std::ostream& operator<<( std::ostream& os, const GenericProcess* proc );

	/// Generic map of particles with their role in the process
	typedef std::map<Particle::Role,Particle::ParticleCode> ParticlesRoleMap;
	/// Pair of particle with their associated role in the process
	typedef std::pair<Particle::Role,Particle::ParticleCode> ParticleWithRole;
	/// Map of all incoming state particles in the process
	typedef ParticlesRoleMap IncomingState;
	/// Map of all outgoing particles in the process
	typedef ParticlesRoleMap OutgoingState;

	/// Default constructor for an undefined process
	/// \param[in] name_ Human-readable format of the process name
	GenericProcess( const std::string& name_="<invalid process>" );
	virtual ~GenericProcess();

	/// Restore the Event object to its initial state
	inline void ClearEvent() { fEvent->Restore(); }
	/// Set the kinematics of the incoming state particles
	void SetIncomingKinematics( const Particle::Momentum& p1, const Particle::Momentum& p2 );
	/// Compute the incoming state kinematics
	void PrepareKinematics();

	// --- virtual (process-defined) methods

	public:
	/// Set the incoming and outgoing state to be expected in the process
	- inline virtual void AddEventContent() {
	- InWarning( "Virtual method called" );
	- }
	+ inline virtual void AddEventContent() { InWarning( "Virtual method called" ); }
	/// Prepare the process for its integration over the whole phase space
	- inline virtual void BeforeComputeWeight() {
	- Debugging( "Virtual method called" );
	- }
	+ inline virtual void BeforeComputeWeight() { Debugging( "Virtual method called" ); }
	/// Compute the weight for this point in the phase-space
	inline virtual double ComputeWeight() { throw Exception(__PRETTY_FUNCTION__, "Calling ComputeWeight on an invalid process!", FatalError); }
	/// Fill the Event object with the particles' kinematics
	/// \param[in] symmetrise_ Symmetrise the event? (randomise the production of positively-
	/// and negatively-charged outgoing central particles)
	inline virtual void FillKinematics( bool symmetrise_=false ) {
	InWarning( "Virtual method called" );
	if ( symmetrise_ ) Information( "The kinematics is symmetrised" );
	}
	/// Return the number of dimensions on which the integration has to be performed
	/// \return Number of dimensions on which to integrate
	inline virtual unsigned int GetNdim( const Kinematics::ProcessMode& ) const {
	InWarning( "Virtual method called" );
	return 0;
	}
	/// Set the list of kinematic cuts to apply on the outgoing particles' final state
	/// \param[in] cuts_ The Cuts object containing the kinematic parameters
	inline virtual void SetKinematics( const Kinematics& cuts_ ) {
	Debugging( "Virtual method called" );
	fCuts = cuts_;
	}

	public:
	/**
	* Sets the phase space point to compute the weight associated to it.
	* @brief Sets the phase space point to compute
	* @param[in] ndim_ The number of dimensions of the point in the phase space
	* @param[in] x_[] The (@a ndim_)-dimensional point in the phase space on
	* which the kinematics and the cross-section are computed
	*/
	void SetPoint( const unsigned int ndim_, double x_[] );
	/// Dump the evaluated point's coordinates in the standard output stream
	void DumpPoint( const ExceptionType& et );
	/// Complete list of Particle with their role in the process for the point considered
	/// in the phase space, returned as an Event object.
	/// \return Event object containing all the generated Particle objects
	inline Event* GetEvent() { return fEvent; }
	///Get the number of dimensions on which the integration is performed
	inline unsigned int ndim() const { return fNumDimensions; }
	/// Get the value of a component of the @a fNumDimensions -dimensional point considered
	inline double x( const unsigned int idx_ ) const { return ( idx_>=fNumDimensions ) ? -1. : fX[idx_]; }
	/// Get a human-readable name of the process considered
	inline std::string GetName() const { return fName; }

	/// Reset the total generation time and the number of events generated for this run
	inline void ClearRun() {
	fTotalGenTime = 0.;
	fNumGenEvents = 0;
	}
	/// Add a new timing into the total generation time
	/// \param[in] gen_time Time to add (in seconds)
	inline void AddGenerationTime( const float& gen_time ) {
	fTotalGenTime += gen_time;
	fNumGenEvents++;
	}
	/// Return the total generation time for this run (in seconds)
	inline float TotalGenerationTime() const { return fTotalGenTime; }
	/// Total number of events already generated in this run
	inline unsigned int NumGeneratedEvents() const { return fNumGenEvents; }

	protected:
	/// Set the incoming and outgoing states to be defined in this process (and prepare the Event object accordingly)
	void SetEventContent( const IncomingState& is, const OutgoingState& os );

	/// Get a list of pointers to the particles with a given role in the process
	/// \param[in] role role in the process for the particle to retrieve
	/// \return A vector of pointers to Particle objects associated to the role
	inline ParticlesRef GetParticles( const Particle::Role& role ) { return fEvent->GetByRole( role ); }
	/// Get the pointer to one particle in the event (using its role)
	inline Particle* GetParticle( const Particle::Role& role, unsigned int id=0 ) {
	if ( id==0 ) return fEvent->GetOneByRole( role );
	ParticlesRef pp = fEvent->GetByRole( role );
	if ( !pp.size() or id>pp.size() ) return 0;
	return pp.at( id );
	}
	/// Get the pointer to one particle in the event (using its identifier)
	inline Particle* GetParticle( unsigned int id ) { return fEvent->GetById( id ); }

	// ---

	/// Array of @a fNumDimensions components representing the point on which the weight in the cross-section is computed
	double* fX;
	/// List of incoming state particles (including intermediate partons)
	IncomingState fIncomingState;
	/// List of outgoing state particles
	OutgoingState fOutgoingState;
	/// \f$s\f$, squared centre of mass energy of the incoming particles' system, in \f$\mathrm{GeV}^2\f$
	double fS;
	/// \f$\sqrt s\f$, centre of mass energy of the incoming particles' system (in GeV)
	double fSqS;
	/// Invariant mass of the first proton-like outgoing particle (or remnant)
	double fMX;
	/// Invariant mass of the second proton-like outgoing particle (or remnant)
	double fMY;

	/// Number of dimensions on which the integration has to be performed.
	unsigned int fNumDimensions;
	/// Set of cuts to apply on the final phase space
	Kinematics fCuts;
	/// Event object containing all the information on the in- and outgoing particles
	Event* fEvent;
	/// Is the phase space point set?
	bool fIsPointSet;
	/// Are the event's incoming particles set?
	bool fIsInStateSet;
	/// Are the event's outgoing particles set?
	bool fIsOutStateSet;
	/// Is the full event's kinematic set?
	bool fIsKinematicSet;
	/// Name of the process (useful for logging and debugging)
	std::string fName;
	/// Total generation time (in seconds)
	float fTotalGenTime;
	/// Number of events already generated
	unsigned int fNumGenEvents;

	+ double* w1_;
	+ double* w2_;
	+ double* w3_;
	+ double* w5_;
	+
	private:
	/**
	* Is the system's kinematics well defined and compatible with the process ?
	* This check is mandatory to perform the (@a fNumDimensions)-dimensional point's
	* cross-section computation.
	* @brief Is the system's kinematics well defined?
	* @return A boolean stating if the input kinematics and the final states are
	* well defined
	*/
	inline bool IsKinematicsDefined() {
	if (GetParticles(Particle::IncomingBeam1).size()!=0 and GetParticles(Particle::IncomingBeam2).size()!=0) fIsInStateSet = true;
	if ((GetParticles(Particle::OutgoingBeam1).size()!=0 and GetParticles(Particle::OutgoingBeam2).size()!=0)
	and (GetParticles(Particle::CentralParticle1).size()!=0 or GetParticles(Particle::CentralParticle2).size()!=0)) fIsOutStateSet = true;
	fIsKinematicSet = fIsInStateSet and fIsOutStateSet;
	return fIsKinematicSet;
	}

	};

	#endif
	diff --git a/utils/GenericCanvas.h b/utils/GenericCanvas.h
	index 603864a..ba781a8 100644
	--- a/utils/GenericCanvas.h
	+++ b/utils/GenericCanvas.h
	@@ -1,169 +1,169 @@
	#ifndef GenericCanvas_h
	#define GenericCanvas_h

	#include "TCanvas.h"
	#include "TPaveText.h"
	#include "TLegend.h"
	#include "TStyle.h"
	#include "TAxis.h"
	#include "TGraph.h"
	#include "TF1.h"
	#include "TH1.h"

	/**
	* \author Laurent Forthomme <laurent.forthomme@cern.ch>
	* \date 25 Jul 2015
	*/
	class GenericCanvas : public TCanvas
	{
	public:
	inline GenericCanvas() :
	TCanvas( "null" ), fBuilt( false ),
	fLegend( 0 ), fLegendX(.55), fLegendY( .74 ), fLegendNumEntries( 0 ),
	fUpperLabel( 0 ), fLabelsDrawn(false) {;}
	inline GenericCanvas( TString name, unsigned int width=500, unsigned int height=500, TString upper_label="" ) :
	TCanvas( name, "", width, height ), fBuilt( false ), fWidth( width ), fHeight( height ),
	fLegend( 0 ), fLegendX( .55 ), fLegendY( .74 ), fLegendNumEntries( 0 ),
	fUpperLabelText( upper_label ), fUpperLabel( 0 ), fLabelsDrawn( false ) { Build(); }
	inline GenericCanvas( TString name, TString upper_label ) :
	TCanvas( name, "", 500, 500 ), fBuilt( false ), fWidth( 500 ), fHeight( 500 ),
	fLegend( 0 ), fLegendX( .55 ), fLegendY( .74 ), fLegendNumEntries( 0 ),
	fUpperLabelText( upper_label ), fUpperLabel( 0 ), fLabelsDrawn( false ) { Build(); }

	inline virtual ~GenericCanvas() {
	if ( fLegend ) delete fLegend;
	if ( fUpperLabel ) delete fUpperLabel;
	}

	inline void SetUpperLabel( TString text="" ) {
	if ( text=="" ) return;
	fUpperLabelText = text;
	fUpperLabel = new TPaveText( .5, .945, .945, .98, "ndc" );
	fUpperLabel->SetMargin( 0. );
	fUpperLabel->SetFillColor( kWhite );
	fUpperLabel->SetLineColor( kWhite );
	fUpperLabel->SetLineWidth( 0 );
	fUpperLabel->SetShadowColor( kWhite );
	fUpperLabel->SetTextFont( 43 );
	fUpperLabel->SetTextAlign( 33 );
	fUpperLabel->SetTextSize( 18 );
	fUpperLabel->AddText( fUpperLabelText );
	fUpperLabel->Draw( "same" );
	}

	inline void Save( TString ext="png", TString path="." ) {
	bool valid_ext = true;
	valid_ext \|= ( strcmp( ext.Data(), "png" )!=0 );
	valid_ext \|= ( strcmp( ext.Data(), "pdf" )!=0 );
	if ( !valid_ext ) return;
	DrawLabels();
	//printf( "File saved as %s\n", Form( "%s/%s.%s", path.Data(), TCanvas::GetName(), ext.Data() ) );
	TCanvas::SaveAs( Form( "%s/%s.%s", path.Data(), TCanvas::GetName(), ext.Data() ) );
	//c1->SetLogz();
	//TCanvas::SaveAs( Form( "%s/%s_logscale.%s", path.Data(), TCanvas::GetName(), ext.Data() ) );
	}
	inline TPad* Pad() { return c1; }

	void AddLegendEntry( const TObject* obj_, TString label_, Option_t* option_="lf" ) {
	fLegend->AddEntry( obj_, label_, option_ );
	fLegendNumEntries++;
	if ( fLegendNumEntries>3 ) {
	fLegend->SetY1( fLegend->GetY1()-( fLegendNumEntries-3 )*0.015 );
	}
	}

	inline void Prettify( TH1* o ) {
	- Prettify( dynamic_cast<TGraph*>( o ) );
	+ Prettify( o->GetXaxis(), o->GetYaxis() );
	o->SetTitle("");
	}
	inline void Prettify( TF1* o ) {
	Prettify( o->GetXaxis(), o->GetYaxis() );
	o->SetTitle("");
	}
	inline void Prettify( TGraph* o ) {
	Prettify( o->GetHistogram()->GetXaxis(), o->GetHistogram()->GetYaxis() );
	o->SetTitle("");
	}
	inline void Prettify( TAxis* x, TAxis* y=0 ) {
	// O so pretty axis!
	x->SetTitleFont( 43 );
	x->SetTitleSize( 28 );
	x->SetLabelFont( 43 );
	x->SetLabelSize( 22 );
	x->SetTitleOffset( 0.85 );

	if ( !y ) return;
	y->SetTitleFont( 43 );
	y->SetTitleSize( 28 );
	y->SetLabelFont( 43 );
	y->SetLabelSize( 22 );
	y->SetTitleOffset( 1.18 );
	}

	protected:
	inline void Build() {
	if ( fBuilt ) return;
	fLegend = new TLegend( fLegendX, fLegendY, fLegendX+.35, fLegendY+.15 );
	fLegend->SetFillColor( kWhite );
	fLegend->SetLineColor( kWhite );
	fLegend->SetLineWidth( 0 );
	fLegend->SetTextFont( 43 );
	fLegend->SetTextSize( 22 );
	DrawGrid();
	fBuilt = true;
	}

	private:
	inline void DrawLabels() {
	//if (fLabelsDrawn) return;

	if ( fLegend->GetNRows()!=0 ) fLegend->Draw();
	SetUpperLabel( fUpperLabelText );
	fLabelsDrawn = true;

	gStyle->SetMarkerStyle( 20 );
	gStyle->SetMarkerSize( .87 );
	gStyle->SetTitleFont( 43, "XYZ" );
	gStyle->SetTitleSize( 24, "XYZ" );
	//gStyle->SetTitleOffset( 2., "Y" );
	gStyle->SetLabelFont( 43, "XYZ" );
	gStyle->SetLabelSize( 20, "XY" );
	gStyle->SetLabelSize( 15, "Z" );
	gStyle->SetTitleOffset( 0.9, "X" );
	gStyle->SetTitleOffset( 1.1, "Y" );
	gStyle->SetHistLineColor( kBlack );
	gStyle->SetHistLineWidth( 2 );
	}

	inline void DrawGrid() {
	TCanvas::cd();
	gStyle->SetOptStat( 0 );

	TCanvas::Divide( 1, 2 );
	c1 = dynamic_cast<TPad*>( TCanvas::GetPad( 1 ) );
	c2 = dynamic_cast<TPad*>( TCanvas::GetPad( 2 ) );
	c1->SetPad( 0., 0., 1., 1. );
	c2->SetPad( 0., 0., 1., 0. );
	c1->SetBottomMargin( 0.12 );
	c1->SetLeftMargin( 0.16 );
	c1->SetRightMargin( 0.05 );
	c1->SetTopMargin( 0.08 );
	TCanvas::cd( 1 );

	c1->SetTicks( 1, 1 );
	//c1->SetGrid( 1, 1 );
	}

	bool fBuilt;
	TPad c1, c2;
	double fWidth, fHeight;
	TLegend *fLegend;
	double fLegendX, fLegendY;
	unsigned int fLegendNumEntries;
	TPaveText fLabel1, fLabel2;
	TString fUpperLabelText;
	TPaveText *fUpperLabel;
	bool fLabelsDrawn;
	};

	#endif
	diff --git a/utils/inelasticparticle.cpp b/utils/inelasticparticle.cpp
	index 353bb30..6133e37 100644
	--- a/utils/inelasticparticle.cpp
	+++ b/utils/inelasticparticle.cpp
	@@ -1,80 +1,27 @@
	-#include "../export/EventWriter.h"
	+#include "export/HepMCHandler.h"

	using namespace std;

	int main() {

	- EventWriter writer(EventWriter::HepMC, "example.dat");
	+ OutputHandler::HepMCHandler writer( "example.dat" );
	writer.SetCrossSection(1., 2.);

	Event ev;

	- Particle p1(Particle::IncomingBeam1, Particle::Proton);
	- p1.SetMomentum(1., -15., 100.);
	+ Particle p1( Particle::IncomingBeam1, Particle::Proton );
	+ p1.SetMomentum( 1., -15., 100. );
	p1.status = Particle::Incoming;
	ev.AddParticle(p1);

	- Particle p2(Particle::IncomingBeam2, Particle::Electron);
	- p2.SetMomentum(10., 5., 3200.);
	+ Particle p2( Particle::IncomingBeam2, Particle::Electron );
	+ p2.SetMomentum( 10., 5., 3200. );
	p2.status = Particle::Incoming;
	ev.AddParticle(p2);

	ev.Dump();

	writer << &ev;

	return 0;
	-
	- //Jetset7Hadroniser js;
	- //js.Hadronise(&ev);
	- //ev.Dump(true);
	-
	- /Particle p1, *p2;
	-
	- p1 = new Particle(1, ELECTRON);
	- p2 = new Particle(2, PROTON);
	- p1->P(0., 0., 27.55);
	- p2->P(0., 0., -820.);
	-
	- PhysicsBoundaries pb;
	- double q2 = 1.;
	-
	- Particles epa = EPA(p1, p2, 1, pb, &q2);
	-
	- Particles::iterator part;
	- for (part=epa.begin(); part!=epa.end(); part++) {
	- part->Dump();
	- }
	-
	- delete p1;
	- delete p2;*/
	-
	- /*Particle vm(1, Particle::JPsi);
	- vm.P(1., 1., 0.);
	- try { vm.Dump(); } catch (Exception& e) { e.Dump(); }*/
	-
	- /*Logger::GetInstance()->Level = Logger::Debug;
	- Event ev;
	- Particle q(1, Particle::uQuark);
	- q.status = -2;
	- q.P(0.5, 0.8, 3000.);
	- ev.AddParticle(q);
	- ev.Dump();
	- Pythia6Hadroniser h;
	- //Jetset7Hadroniser h;
	- try { h.Hadronise(&ev); } catch (Exception &e) { e.Dump(); }
	- ev.Dump();*/
	-
	- /*Particle ele(1, Particle::Electron);
	- ele.SetMomentum(0., 0., 27.5);
	- //ele.SetM();
	- ele.Dump();
	-
	- Particle pro(2, Particle::Proton);
	- pro.SetMomentum(0., 0., -920.0);
	- pro.Dump();
	-
	- cout << CMEnergy(ele, pro) << endl;*/
	-
	- return 0;
	}
	diff --git a/utils/probe.cpp b/utils/probe.cpp
	index 90eadd0..c3f5137 100644
	--- a/utils/probe.cpp
	+++ b/utils/probe.cpp
	@@ -1,28 +1,29 @@
	-#include "../include/MCGen.h"
	+#include "core/MCGen.h"

	using namespace std;

	int main()
	{
	MCGen g;
	Parameters* p = g.parameters;
	//p->process = new GamGamLL;
	p->process = new PPtoLL;
	- p->process_mode = GenericProcess::ElasticElastic;
	- //p->process_mode = GenericProcess::InelasticElastic;
	- //p->process_mode = GenericProcess::ElasticInelastic;
	+ p->process_mode = Kinematics::ElasticElastic;
	+ //p->process_mode = Kinematics::InelasticElastic;
	+ //p->process_mode = Kinematics::ElasticInelastic;
	p->minpt = 5.;
	p->mineta = -2.5; p->maxeta = 2.5;
	p->minmx = 1.07;
	p->maxmx = 320.;

	p->Dump();
	Logger::GetInstance()->Level = Logger::DebugInsideLoop;

	- const unsigned int ndim = g.GetNdim(); double x[ndim];
	+ const unsigned int ndim = g.GetNdim();
	+ double x[ndim];
	for (unsigned int i=0; i<ndim; i++) { x[i] = 0.3;}

	cout << g.ComputePoint(x) << endl;

	return 0;
	}
	diff --git a/utils/xsect.cpp b/utils/xsect.cpp
	index 310ac91..987d32e 100644
	--- a/utils/xsect.cpp
	+++ b/utils/xsect.cpp
	@@ -1,73 +1,73 @@
	#include <iostream>
	#include <fstream>

	-#include "../include/MCGen.h"
	+#include "core/MCGen.h"
	/**
	* \author Laurent Forthomme <laurent.forthomme@cern.ch>
	*/
	int main(int argc, char* argv[]) {
	Parameters ip;
	double xsec, err, minpt, sqs;
	double min, max;
	std::ofstream tmp;
	int it;
	MCGen *mg;

	// max = 10.;
	//max = 10.;
	min = 0.;
	max = 50.;
	it = 100;
	//max = 14000.;
	/*min = 10.;
	max = 60.;
	it = 50;*/

	if (argc>1) it = atoi(argv[1]);

	ip.in1p = 3500.;
	ip.in2p = 3500.;
	ip.process = new GamGamLL;
	//ip.hadroniser = new Pythia6Hadroniser;
	- //ip.process_mode = GenericProcess::ElasticElastic;
	- //ip.process_mode = GenericProcess::InelasticElastic;
	- ip.process_mode = GenericProcess::InelasticInelastic;
	+ //ip.process_mode = Kinematics::ElasticElastic;
	+ //ip.process_mode = Kinematics::InelasticElastic;
	+ ip.process_mode = Kinematics::InelasticInelastic;
	ip.pair = Particle::Muon;
	ip.remnant_mode = GenericProcess::SuriYennie;
	//ip.SetThetaRange(5., 175.);
	//ip.SetThetaRange(0., 180.);
	ip.mineta =-2.5;
	ip.maxeta = 2.5;
	ip.maxmx = 1000.;
	- ip.mcut = 2;
	+ ip.mcut = Kinematics::BothParticles;
	ip.minenergy = 0.;
	// DEBUG
	//ip.itvg = 5;
	//ip.ncvg = 50000;
	//
	ip.minpt = 15.;
	ip.generation = false;
	ip.Dump();

	//tmp.open("tmp/xsec_lpairpp_elastic.dat");
	//tmp.open("tmp/xsec_lpairpp_singleinelastic.dat");
	tmp.open("tmp/xsec_lpairpp_doubleinelastic_v2.dat");
	//tmp.open("tmp/xsec_sqs_lpairpp_elastic_noetacut.dat");
	//tmp.open("tmp.dat");
	//tmp.open("tmp/xsec_sqs_lpairpp_singleinelastic_noetacut.dat");
	//tmp.open("tmp/xsec_sqs_lpairpp_doubleinelastic_noetacut.dat");
	mg = new MCGen(&ip);
	for (int i=0; i<=it; i++) {
	minpt = min+i/(double)it*(max-min);
	mg->parameters->minpt = minpt;
	//sqs = min+(double)i/(double)it*(max-min);
	//ip.in1p = sqs/2.;
	//ip.in2p = sqs/2.;
	mg->ComputeXsection(&xsec, &err);
	std::cout << minpt << "\t" << xsec << "\t" << err << std::endl;
	tmp << minpt << "\t" << xsec << "\t" << err << std::endl;
	}
	delete mg;
	return 0;
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Nov 19, 7:23 PM (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3805812
Default Alt Text: (238 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions